{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第7章.处理文本处理\n",
    "<P>在文本分析的语境中,数据集通常都被称为语料库，每个由单个文本表示的数据点被称为文档</P>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.2.示例应用:电影评论的情感分析\n",
    "<p>pos文件夹包含所有正面评价,neg文件夹包含所有负面评价.sklearn中有一个辅助函数可以加载用这种文件夹结构保存的文件，其中每个子文件夹对应一个标签,这个函数叫做load_files</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of text_train:<class 'list'>\n",
      "length of text_train:25000\n",
      "text_train[1]:\n",
      "b'Words can\\'t describe how bad this movie is. I can\\'t explain it by writing only. You have too see it for yourself to get at grip of how horrible a movie really can be. Not that I recommend you to do that. There are so many clich\\xc3\\xa9s, mistakes (and all other negative things you can imagine) here that will just make you cry. To start with the technical first, there are a LOT of mistakes regarding the airplane. I won\\'t list them here, but just mention the coloring of the plane. They didn\\'t even manage to show an airliner in the colors of a fictional airline, but instead used a 747 painted in the original Boeing livery. Very bad. The plot is stupid and has been done many times before, only much, much better. There are so many ridiculous moments here that i lost count of it really early. Also, I was on the bad guys\\' side all the time in the movie, because the good guys were so stupid. \"Executive Decision\" should without a doubt be you\\'re choice over this one, even the \"Turbulence\"-movies are better. In fact, every other movie in the world is better than this one.'\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_files\n",
    "# load_files返回一个Bunch对象,其中包含训练文本和标签\n",
    "reviews_train = load_files(\"F:/python学习资料/aclImdb_v1/aclImdb/train/\")\n",
    "text_train,y_train = reviews_train.data,reviews_train.target\n",
    "print(\"type of text_train:{}\".format(type(text_train)))\n",
    "print(\"length of text_train:{}\".format(len(text_train)))\n",
    "print(\"text_train[1]:\\n{}\".format(text_train[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 如上所示,text_train为一个25000的列表,其中每一个元素为包含一条评论的字符串，我们打印出索引为1的评论后。我们发现评论中有html标签。我们需要清楚一下这些标签"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_train = [doc.replace(b\"<br />\",b\" \") for doc in text_train]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Samples per class:[12500 12500]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(\"Samples per class:{}\".format(np.bincount(y_train)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of documents in test data:25000\n",
      "Samples per class(test);[12500 12500]\n"
     ]
    }
   ],
   "source": [
    "# 加载测试数据集\n",
    "reviews_test = load_files(\"F:/python学习资料/aclImdb_v1/aclImdb/test/\")\n",
    "text_test,y_test = reviews_test.data,reviews_test.target\n",
    "print(\"Number of documents in test data:{}\".format(len(text_test)))\n",
    "print(\"Samples per class(test);{}\".format(np.bincount(y_test)))\n",
    "text_test = [doc.replace(b\"<br/>\",b\" \") for doc in text_test]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<P>我们的任务式根据评论的文本内容对其分配一个\"正面的\"或\"负面的\"评价。但是文本数据并不是机器学习可以直接处理的格式，因此，我们要将文本数据转化为机器学习的表现形式</P>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.3.将文本数据表示为词袋\n",
    "<p>使用词袋表示文本数据时,我们舍弃了输入文本中的大部分结构比如章节,段落，句子和格式等。只计算语料库中每个单词在单个文本中出现的频次。计算词袋表示包括如下步骤</p>\n",
    "<UL>\n",
    "    <LI>分词:将每个文档划分为出现在其中的单词(称为词例),比如按空格和标点划分</LI>\n",
    "    <LI>构建词表:收集一个词表,里面包含出现在任意文档中的所有词,并对他们进行编号(比如按字母顺序走)</LI>\n",
    "    <LI>编码:对于每个文档,计算词表中每个单词在文档中的出现频次</LI>\n",
    "</UL>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.1 将词袋应用于玩具数据集\n",
    "<p>词袋表示是在CountVectorizer中实现</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CountVectorizer()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "bards_words = ['The fool doth think he is wise','but the wise man knows himself to be a fool']\n",
    "vect = CountVectorizer()\n",
    "vect.fit(bards_words) # 构建词表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulary size:13\n",
      "Vocabulary content:{'the': 9, 'fool': 3, 'doth': 2, 'think': 10, 'he': 4, 'is': 6, 'wise': 12, 'but': 1, 'man': 8, 'knows': 7, 'himself': 5, 'to': 11, 'be': 0}\n"
     ]
    }
   ],
   "source": [
    "# 我们可以通过vocabulary_属性来访问词表\n",
    "print(\"Vocabulary size:{}\".format(len(vect.vocabulary_)))\n",
    "print(\"Vocabulary content:{}\".format(vect.vocabulary_))\n",
    "# 总计包含13个词,从be到wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bag_of_words:<2x13 sparse matrix of type '<class 'numpy.int64'>'\n",
      "\twith 16 stored elements in Compressed Sparse Row format>\n",
      "Dense representation of bag_of_words:\n",
      "[[0 0 1 1 1 0 1 0 0 1 1 0 1]\n",
      " [1 1 0 1 0 1 0 1 1 1 0 1 1]]\n"
     ]
    }
   ],
   "source": [
    "# 调用transform方法,来创建训练数据的词袋表示\n",
    "bag_of_words = vect.transform(bards_words)\n",
    "# 词袋保存在一个scipy的稀疏矩阵中\n",
    "print(\"bag_of_words:{}\".format(repr(bag_of_words)))\n",
    "print(\"Dense representation of bag_of_words:\\n{}\".format(bag_of_words.toarray()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.2 将词袋应用于电影评论"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:\n",
      "<25000x74849 sparse matrix of type '<class 'numpy.int64'>'\n",
      "\twith 3431196 stored elements in Compressed Sparse Row format>\n"
     ]
    }
   ],
   "source": [
    "vect = CountVectorizer().fit(text_train)\n",
    "X_train = vect.transform(text_train)\n",
    "print(\"X_train:\\n{}\".format(repr(X_train)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of features:74849\n",
      "First 20 feature:\n",
      "['00', '000', '0000000000001', '00001', '00015', '000s', '001', '003830', '006', '007', '0079', '0080', '0083', '0093638', '00am', '00pm', '00s', '01', '01pm', '02']\n",
      "Features 20010 to 20030:\n",
      "['dratted', 'draub', 'draught', 'draughts', 'draughtswoman', 'draw', 'drawback', 'drawbacks', 'drawer', 'drawers', 'drawing', 'drawings', 'drawl', 'drawled', 'drawling', 'drawn', 'draws', 'draza', 'dre', 'drea']\n",
      "Every 2000th feature:\n",
      "['00', 'aesir', 'aquarian', 'barking', 'blustering', 'bête', 'chicanery', 'condensing', 'cunning', 'detox', 'draper', 'enshrined', 'favorit', 'freezer', 'goldman', 'hasan', 'huitieme', 'intelligible', 'kantrowitz', 'lawful', 'maars', 'megalunged', 'mostey', 'norrland', 'padilla', 'pincher', 'promisingly', 'receptionist', 'rivals', 'schnaas', 'shunning', 'sparse', 'subset', 'temptations', 'treatises', 'unproven', 'walkman', 'xylophonist']\n"
     ]
    }
   ],
   "source": [
    "# 访问词表的另一种方法使用向量器的get_feature_name方法\n",
    "feature_names = vect.get_feature_names()\n",
    "print(\"Number of features:{}\".format(len(feature_names)))\n",
    "print(\"First 20 feature:\\n{}\".format(feature_names[:20]))\n",
    "print(\"Features 20010 to 20030:\\n{}\".format(feature_names[20010:20030]))\n",
    "print(\"Every 2000th feature:\\n{}\".format(feature_names[::2000])) # 隔2000个"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean cross-validation accuracy :0.881\n"
     ]
    }
   ],
   "source": [
    "# 使用交叉验证对logisticRegression做评估\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "scores = cross_val_score(LogisticRegression(max_iter=1200),X_train,y_train,cv=5)\n",
    "print(\"Mean cross-validation accuracy :{:.3f}\".format(np.mean(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation score:0.89\n",
      "Best parameters: {'C': 0.1}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "param_grid = {\"C\":[0.001,0.01,0.1,1,10]}\n",
    "grid = GridSearchCV(LogisticRegression(max_iter=1200),param_grid,cv=5,n_jobs=-1)\n",
    "grid.fit(X_train,y_train)\n",
    "print(\"Best cross-validation score:{:.2f}\".format(grid.best_score_))\n",
    "print(\"Best parameters:\",grid.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.97\n"
     ]
    }
   ],
   "source": [
    "# 评估该模型在测试集上的范化性能\n",
    "X_test = vect.transform(text_test)\n",
    "print(\"{:.2f}\".format(grid.score(X_test,y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<P>我们应当改进一下单词提取以增加计算速度.CountVectorizer使用正则表达式提取词列.默认使用的是正则表达式\"\\b\\w\\w+\\b\".之后他会将找到的词变换为小写形式。虽然这种方法简单有效,但是我们同时得到了许多不包含信息量的特征,比如数字。减少这种特征的方法：仅使用至少在两个文档中出现的词汇，我们可以使用min_df参数来设置词列</P>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train with min_df:<25000x27271 sparse matrix of type '<class 'numpy.int64'>'\n",
      "\twith 3354014 stored elements in Compressed Sparse Row format>\n"
     ]
    }
   ],
   "source": [
    "vect = CountVectorizer(min_df=5).fit(text_train)\n",
    "X_train = vect.transform(text_train)\n",
    "print(\"X_train with min_df:{}\".format(repr(X_train)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 50 features:\n",
      "['00', '000', '0000000000001', '00001', '00015', '000s', '001', '003830', '006', '007', '0079', '0080', '0083', '0093638', '00am', '00pm', '00s', '01', '01pm', '02', '020410', '029', '03', '04', '041', '05', '050', '06', '06th', '07', '08', '087', '089', '08th', '09', '0f', '0ne', '0r', '0s', '10', '100', '1000', '1000000', '10000000000000', '1000lb', '1000s', '1001', '100b', '100k', '100m']\n",
      "Features 20010 to 20030:\n",
      "['dratted', 'draub', 'draught', 'draughts', 'draughtswoman', 'draw', 'drawback', 'drawbacks', 'drawer', 'drawers', 'drawing', 'drawings', 'drawl', 'drawled', 'drawling', 'drawn', 'draws', 'draza', 'dre', 'drea']\n",
      "Every 700th feature:\n",
      "['00', '40s', 'accent', 'aforementioned', 'aloysius', 'annoucing', 'aristocratic', 'attired', 'bainter', 'bayonets', 'bersen', 'blaze', 'bookstores', 'brighton', 'bursting', 'capers', 'cbbc', 'chemstrand', 'clad', 'colin', 'condensing', 'coolidge', 'cray', 'cusp', 'dears', 'dempster', 'dialing', 'dislocated', 'donnacha', 'duchaussoy', 'eeriest', 'enactment', 'erupt', 'exoskeleton', 'fare', 'figuring', 'flowing', 'fraternal', 'gait', 'gesture', 'goldman', 'grimmer', 'hagan', 'haun', 'heterosexism', 'honhyol', 'hushed', 'import', 'ingenious', 'introspection', 'jardine', 'juli', 'kevetch', 'kovacks', 'larval', 'lev', 'locoformovies', 'luxor', 'managers', 'masterton', 'megalunged', 'mikhalkov', 'modernization', 'mountie', 'naidu', 'newswomen', 'nudeness', 'ominous', 'outwits', 'papers', 'peeping', 'phineas', 'plethora', 'pottery', 'procedure', 'pulpits', 'radulescu', 'reassured', 'reiterates', 'restaraunt', 'rivals', 'ruckus', 'sanguine', 'schygula', 'sensation', 'shelob', 'signpost', 'slipstream', 'solutions', 'splaining', 'steakley', 'stronger', 'superball', 'synch', 'techies', 'thier', 'tokes', 'traped', 'turiquistan', 'undercard', 'unproven', 'validate', 'villan', 'warbeck', 'whiners', 'wonderland', 'yeoh']\n"
     ]
    }
   ],
   "source": [
    "features_names = vect.get_feature_names()\n",
    "\n",
    "print(\"First 50 features:\\n{}\".format(feature_names[:50]))\n",
    "print(\"Features 20010 to 20030:\\n{}\".format(feature_names[20010:20030]))\n",
    "print(\"Every 700th feature:\\n{}\".format(feature_names[::700]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation score:0.89\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\myAnaconda\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:762: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "grid = GridSearchCV(LogisticRegression(),param_grid,cv=5,n_jobs=-1)\n",
    "grid.fit(X_train,y_train)\n",
    "print(\"Best cross-validation score:{:.2f}\".format(grid.best_score_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.4 停用词\n",
    "<P>删除没有信息量的单词还有另一种方法,就是舍弃那些出现次数太多以至于没有信息量的单词。有两种方法：使用特定语言的停用词(stopwords)列表,或者舍弃那些出现过于频繁的单词。sklearn中的feature_extraction.text模块中提供了英语停用词的内置列表</P>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of stop words:318\n",
      "Every 10th stopped:\n",
      "['hers', 'as', 'six', 'last', 'side', 'what', 'nowhere', 'were', 'again', 'some', 'elsewhere', 'into', 'please', 'it', 'or', 'him', 'either', 'done', 'take', 'mostly', 'otherwise', 'through', 'whole', 'being', 'third', 'while', 'within', 'noone', 'us', 'between', 'must', 'might']\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS\n",
    "print(\"Number of stop words:{}\".format(len(ENGLISH_STOP_WORDS)))\n",
    "print(\"Every 10th stopped:\\n{}\".format(list(ENGLISH_STOP_WORDS)[::10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train with stop words:\n",
      "<25000x26966 sparse matrix of type '<class 'numpy.int64'>'\n",
      "\twith 2149958 stored elements in Compressed Sparse Row format>\n"
     ]
    }
   ],
   "source": [
    "# 指定stop_words='english'将使用内置列表\n",
    "vect = CountVectorizer(min_df=5,stop_words='english').fit(text_train)\n",
    "X_train=vect.transform(text_train)\n",
    "print(\"X_train with stop words:\\n{}\".format(repr(X_train)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "交叉验证最好的精度:0.8828400000000001\n"
     ]
    }
   ],
   "source": [
    "grid = GridSearchCV(LogisticRegression(max_iter=1200),param_grid,cv=5)\n",
    "grid.fit(X_train,y_train)\n",
    "print(\"交叉验证最好的精度:{}\".format(grid.best_score_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.5 用tf-idf缩放数据\n",
    "<P>词频-逆文档频率(tf-idf),这一方法对在某个文档中经常出现的术语给予很高权重，但对在语料库的许多文档中都常出现的属于给予的权重却不高。如果一个单词在某个特定文档中经常出现，而在许多文档中却不常出现，那，这个单词可能是对文档内容很好的描述。sklearn中有两个类实现了tf-idf方法(TfidfTransformer和TfidfVectorizer)，前者接受CountVectoriser生成的稀疏矩阵并将其变换，后者接受文本数据并完成词袋特征提取与tf-idf转换</P>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation score:0.89\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "pipe = make_pipeline(TfidfVectorizer(min_df=5),LogisticRegression(max_iter=1000))\n",
    "param_grid = {'logisticregression__C':[0.001,0.01,0.1,1,10]}\n",
    "\n",
    "grid = GridSearchCV(pipe,param_grid,cv=5)\n",
    "grid.fit(text_train,y_train)\n",
    "print(\"Best cross-validation score:{:.2f}\".format(grid.best_score_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Features with lower tfidf:\n",
      "['suplexes' 'gauche' 'hypocrites' 'oncoming' 'galadriel' 'songwriting'\n",
      " 'cataclysmic' 'sylvain' 'emerald' 'mclaughlin' 'oversee' 'pressuring'\n",
      " 'uphold' 'thieving' 'inconsiderate' 'ware' 'denim' 'booed' 'reverting'\n",
      " 'spacious']\n",
      "Features with highest tfidf:\n",
      "['muppet' 'brendan' 'zatoichi' 'dev' 'demons' 'lennon' 'bye' 'weller'\n",
      " 'woo' 'sasquatch' 'botched' 'xica' 'darkman' 'casper' 'doodlebops'\n",
      " 'steve' 'smallville' 'wei' 'scanners' 'pokemon']\n"
     ]
    }
   ],
   "source": [
    "vectorizer = grid.best_estimator_.named_steps['tfidfvectorizer']\n",
    "# 变换训练数据集\n",
    "X_train = vectorizer.transform(text_train)\n",
    "# 找到数据集中每个特征的最大值\n",
    "max_value = X_train.max(axis=0).toarray().ravel()\n",
    "sorted_by_tfidf = max_value.argsort()\n",
    "# 获取特征名称\n",
    "feature_names = np.array(vectorizer.get_feature_names())\n",
    "\n",
    "print(\"Features with lower tfidf:\\n{}\".format(feature_names[sorted_by_tfidf[:20]]))\n",
    "print(\"Features with highest tfidf:\\n{}\".format(feature_names[sorted_by_tfidf[-20:]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Features with lowest idf:\n",
      "['the' 'and' 'of' 'to' 'this' 'is' 'it' 'in' 'that' 'but' 'for' 'with'\n",
      " 'was' 'as' 'on' 'movie' 'not' 'br' 'have' 'one' 'be' 'film' 'are' 'you'\n",
      " 'all' 'at' 'an' 'by' 'so' 'from' 'like' 'who' 'they' 'there' 'if' 'his'\n",
      " 'out' 'just' 'about' 'he' 'or' 'has' 'what' 'some' 'good' 'can' 'more'\n",
      " 'when' 'time' 'up' 'very' 'even' 'only' 'no' 'would' 'my' 'see' 'really'\n",
      " 'story' 'which' 'well' 'had' 'me' 'than' 'much' 'their' 'get' 'were'\n",
      " 'other' 'been' 'do' 'most' 'don' 'her' 'also' 'into' 'first' 'made' 'how'\n",
      " 'great' 'because' 'will' 'people' 'make' 'way' 'could' 'we' 'bad' 'after'\n",
      " 'any' 'too' 'then' 'them' 'she' 'watch' 'think' 'acting' 'movies' 'seen'\n",
      " 'its']\n"
     ]
    }
   ],
   "source": [
    "# 训练集的tf-idf值被保存在idf_属性中\n",
    "sorted_by_idf = np.argsort(vectorizer.idf_) # argsort将数组元素从小到大排列并从小到大的返回数组下标\n",
    "# sorted_by_idf[:100]\n",
    "print(\"Features with lowest idf:\\n{}\".format(feature_names[sorted_by_idf[:100]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.8.研究模型系数\n",
    "<P>查看下Logistic回归学到的系数</P>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import mglearn\n",
    "\n",
    "mglearn.tools.visualize_coefficients(\n",
    "    grid.best_estimator_.named_steps['logisticregression'].coef_,feature_names,n_top_features=40\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.7.多个单词的词袋(n元分词)\n",
    "<p>单个单词的词袋有时会容易收到限制(比如完全舍弃单词的顺序).使用词袋表示时,有一种获取上下文的方法，就是不仅考虑单一词列的计数,而且还考虑相邻的两个或3个词例。两个词例被称为二元分词,三个词例被称为三元分词,更一般的被称为n元分词。我们可以通过改变CountVectorizer和TfidfVectorizer的ngram_range参数来改变作为特征的词例范围。ngram_range参数是一个元组,包含要考虑的词例序列的最小长度和最大长度</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bards_words:\n",
      "['The fool doth think he is wise', 'but the wise man knows himself to be a fool']\n"
     ]
    }
   ],
   "source": [
    "barads_words =['The fool doth think he is wise','but the wise man knows himself to be a fool']\n",
    "print(\"bards_words:\\n{}\".format(bards_words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulary size:13\n",
      "Vocabulary:\n",
      "['be', 'but', 'doth', 'fool', 'he', 'himself', 'is', 'knows', 'man', 'the', 'think', 'to', 'wise']\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "cv = CountVectorizer(ngram_range=(1,1)).fit(barads_words)\n",
    "print(\"Vocabulary size:{}\".format(len(cv.vocabulary_)))\n",
    "print(\"Vocabulary:\\n{}\".format(cv.get_feature_names()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulary size:14\n",
      "Vocabulary:\n",
      "['be fool', 'but the', 'doth think', 'fool doth', 'he is', 'himself to', 'is wise', 'knows himself', 'man knows', 'the fool', 'the wise', 'think he', 'to be', 'wise man']\n"
     ]
    }
   ],
   "source": [
    "# 仅查看二元分词\n",
    "cv = CountVectorizer(ngram_range=(2,2)).fit(bards_words)\n",
    "print(\"Vocabulary size:{}\".format(len(cv.vocabulary_)))\n",
    "print(f\"Vocabulary:\\n{cv.get_feature_names()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulary size:39\n",
      "Vocabulary :\n",
      ":['be', 'be fool', 'but', 'but the', 'but the wise', 'doth', 'doth think', 'doth think he', 'fool', 'fool doth', 'fool doth think', 'he', 'he is', 'he is wise', 'himself', 'himself to', 'himself to be', 'is', 'is wise', 'knows', 'knows himself', 'knows himself to', 'man', 'man knows', 'man knows himself', 'the', 'the fool', 'the fool doth', 'the wise', 'the wise man', 'think', 'think he', 'think he is', 'to', 'to be', 'to be fool', 'wise', 'wise man', 'wise man knows']\n"
     ]
    }
   ],
   "source": [
    "# 使用一元分词，二元分词，三元分词的结果\n",
    "cv = CountVectorizer(ngram_range=(1,3)).fit(bards_words)\n",
    "print(\"Vocabulary size:{}\".format(len(cv.vocabulary_)))\n",
    "print(\"Vocabulary :\\n:{}\".format(cv.get_feature_names()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 在管道上使用三元分词"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best cross-validation score:0.91\n",
      "Best parameters:\n",
      "{'logisticregression__C': 10, 'tfidfvectorizer__ngram_range': (1, 3)}\n"
     ]
    }
   ],
   "source": [
    "pipe = make_pipeline(TfidfVectorizer(min_df=5),LogisticRegression(max_iter=800))\n",
    "# 运行网格搜索要较长时间\n",
    "param_grid = {'logisticregression__C':[0.001,0.01,0.1,1,10],'tfidfvectorizer__ngram_range':[(1,1),(1,2),(1,3)]}\n",
    "\n",
    "grid = GridSearchCV(pipe,param_grid,cv=5)\n",
    "grid.fit(text_train,y_train)\n",
    "print(\"Best cross-validation score:{:.2f}\".format(grid.best_score_))\n",
    "print(\"Best parameters:\\n{}\".format(grid.best_params_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x2bc765b6340>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# 从网格搜索提取分数\n",
    "scores = grid.cv_results_['mean_test_score'].reshape(-1,3).T\n",
    "# 热图可视化\n",
    "heatmap = mglearn.tools.heatmap(scores,xlabel='C',\n",
    "                ylabel='ngram_range',cmap='viridis',fmt='%.3f'\n",
    "                ,xticklabels=param_grid['logisticregression__C'],yticklabels=param_grid['tfidfvectorizer__ngram_range'])\n",
    "plt.colorbar(heatmap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA30AAAE8CAYAAAB0EdhZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5gcxbX38e9RzoCQhEBISGQwJggBJkeRMwiDCRIgck4mg8gZYzIiCpNNsEQwOZkcTDDgbIyNubaxfa/te997Hev945yma1qzqwF2dlfD7/M8++xOT293TXd1VZ2q6h5LKSEiIiIiIiKtqUdXJ0BERERERESaR0GfiIiIiIhIC1PQJyIiIiIi0sIU9ImIiIiIiLQwBX0iIiIiIiItrFdXJ6AjDBs2LI0dO7arkyEiIiIiItIlXn/99T+klIbXe68lgr6xY8fy2muvdXUyREREREREuoSZfdDWe5reKSIiIiIi0sIU9ImIiIiIiLQwBX0iIiIiIiItTEGfiIiIiIhIC1PQJyIiIiIi0sIU9ImIiIiIiLQwBX0iIiIiIiItTEGfiIiIiIhIC2uJL2cXERERERHpKGbfbvO9lCZ1Yko6hkb6REREREREWpiCPhERERERkRamoE9ERERERKSFKegTERERERFpYQr6REREREREWpiCPhERERERkRamoE9ERERERKSFKegTERERERFpYQr6REREREREWpiCPhERERERkRamoE9ERERERKSFKegTERERERFpYQr6REREREREWpiCPhERERERkRamoE9ERERERKSFKegTERERERFpYQr6REREREREWlivrk6AiIiIiIhIZzD7drvvpzSpk1LSubp0pM/MbjCz35vZO9myoWb2mJn9NH7P15VpFBERERERmZt19fTOm4BNK8uOA55IKS0BPBGvRURERERE5DPo0qAvpfQs8KfK4m2AGfH3DGDbTk2UiIiIiIhIC+nqkb56Fkgp/QdA/B5RbyUz29fMXjOz1z7++ONOTaCIiIiIiMjcojsGfQ1JKU1PKU1IKU0YPnx4VydHRERERESkW+qOQd/vzGxBgPj9+y5Oj4iIiIiIyFyrOwZ9s4DJ8fdkYGYXpkVERERERGSu1tVf2XA78CKwlJl9aGZ7A+cCE83sp8DEeC0iIiIiIiKfQZd+OXtKaZc23tqwUxMiIiIiIiLSorrj9E4RERERERHpIF060iciIiIiItIRzL7d5nspTerElHQ/CvpERERERKTbai+YAwV0jdD0ThERERERkRamoE9ERERERKSFKegTERERERFpYQr6REREREREWpiCPhERERERkRamoE9ERERERKSFKegTERERERFpYQr6REREREREWpiCPhERERERkRbWq6sTICIiIiIiX0xm327zvZQmdWJKWtscgz4zM2BXYNGU0ulmNgYYmVJ6pempExERERGRuU57wRwooOtsjUzvvBJYHdglXv8VuKJpKRIREREREZEO08j0ztVSSuPN7A2AlNJ/mlmfJqdLRERERES6GY3gzZ0aGen7h5n1BBKAmQ0H/t3UVImIiIiIiEiHaCTouxS4DxhhZmcBzwFnNzVVIiIiIiIi0iHmOL0zpXSrmb0ObAgYsG1K6YdNT5mIiIiIiIh8bm0GfWY2NHv5e+D2/L2U0p+amTAREREREek8ul+vdbU30vc6fh+fAWOA/4y/5wV+BYxreupERERERETkc2kz6EspjQMws6uBWSmlh+L1ZsBGnZM8EREREZHW0sgXkjc66taR25LW1chXNqySUtq/eJFS+q6ZndHENImIiIiIzHUUXEl31UjQ9wczOwm4BZ/uuRvwx6amSkRERESkE3TkiJpId9VI0LcLcCr+tQ0Az8YyEREREZFOp0BN5NNp5Csb/gQc1glpEREREZEWpUBNpOvMMegzs6fwaZ01UkobNCVF5X5/CfwV+Bfwz5TShGbuT0RERERqNRKo6T42ke6vkemdR2d/9wN2AP7ZnOTMZv2U0h86aV8iIiIiXwgK1ES+WBqZ3vl6ZdHzZvZMk9IjIiIiIp+DAjoRqWpkeufQ7GUPYGVgZNNSVErAo2aWgGtSStMr6doX2BdgzJgxnZAcERERka6jYE5EPqtGpne+jgdghk/rfB/Yu5mJCmumlD4ysxHAY2b2o5TSs8WbEQROB5gwYcJs9xyKiIjIF0dXfJF1Z29LROSzaiToWyal9H/5AjPr26T0fCKl9FH8/r2Z3Qesin9dhIiIiLQABUQiIp2jkaDvBWB8ZdmLdZZ1GDMbCPRIKf01/t4YOL1Z+xMREZHGKFATEZn7tBn0mdlIYBTQ38xWwqd3AgwBBjQ5XQsA95lZkcbbUkoPN3mfIiIin8vcOHWwWE/3i4mItK72Rvo2AaYACwMXZ8v/CpzQxDSRUvoFsEIz9yEiIiIiIvJF0GbQl1KaAcwwsx1SSvd0YppERERERESkg7Q3vXO3lNItwFgzO7L6fkrp4jr/JiIiIiIiIt1Ie9M7B8bvQZ2REBEREREREel47U3vvCZ+n9Z5yREREREREZGONMevbDCz4cA+wNh8/ZTSXs1LloiIiIiIiHSERr6nbybwPeBx4F/NTY6IiIiIiIh0pEaCvgEppWObnhIRERERERHpcD0aWOcBM9u86SkRERERERGRDtdI0HcYHvj9r5n9xcz+amZ/aXbCRERERERE5POb4/TOlNLgzkiIiIiIiIiIdLxGnt45vs7iPwMfpJT+2fFJEhERERERkY7SyINcrgTGAz+I118G3gLmN7P9U0qPNitxIiIiIiIi8vk0ck/fL4GVUkorp5RWBlYE3gE2As5vYtpERERERETkc2ok6Fs6pfRu8SKl9B4eBP6ieckSERERERGRjtDI9M4fm9lVwB3x+qvAT8ysL/CPpqVMREREREREPrdGRvqmAD8DDgeOAH4Ry/4BrN+shImIiIiIiMjn18hXNvwvcFH8VP13h6dIREREREREOkwjX9mwBHAOsCzQr1ieUlq0iekSERERERGRDtDI9M4bgauAf+LTOW8GvtXMRImIiIiIiEjHaCTo659SegKwlNIHKaVpwAbNTZaIiIiIiIh0hEae3vl/ZtYD+KmZHQz8BhjR3GSJiIiIiIhIR2hkpO9wYABwKLAysDswuZmJEhERERERkY7RyNM7X40//xvYs7nJERERERERkY7UyNM7JwAnAovk66eUlm9iukRERERERKQDNHJP363AMcAPgH83NzkiIiIiIiLSkRoJ+j5OKc1qekpERERERESkwzUS9J1qZtcBTwB/KxamlO5tWqoAM9sU+CbQE7gupXRuM/cnIiIiIiLSihoJ+vYElgZ6U07vTEDTgj4z6wlcAUwEPgReNbNZKaX3mrVPERERERGRVtRI0LdCSunLTU9JrVWBn6WUfgFgZncA2wAK+kRERERERD6FRr6n7yUzW7bpKak1Cvh19vrDWCYiIiIiIiKfgqWU2l/B7IfAYsD7+D19BqRmfmWDmU0CNkkpTY3XuwOrppQOydbZF9gXYMyYMSt/8MEHzUrOZzduXPvvv/9+4+t15LbmtJ621RrbKtZT3vlibKtYr7tua07rtcq2REREuoiZvZ5SmlDvvUamd27awelpxIfA6Oz1wsBH+QoppenAdIAJEya0H7mKiIiIiIh8Qc0x6EspdcUQ2qvAEmY2DvgNsDPwtS5Ih4iIiIiIyFytkZG+TpdS+qeZHQw8gn9lww0ppXe7OFkiIiIiIiJznW4Z9AGklB4CHurqdIiIiIiIiMzN5vj0TjM7r5FlIiIiIiIi0v008pUNE+ss26yjEyIiIiIiIiIdr83pnWZ2AHAgsKiZvZ29NRh4vtkJExERERERkc+vvXv6bgO+C5wDHJct/2tK6U9NTZWIiIiIiIh0iDaDvpTSn4E/A7uYWU9ggVh/kJkNSin9qpPSKCIiIiIiIp/RHJ/eGV+dMA34HfDvWJyA5ZuXLBEREREREekIjXxlw+HAUimlPzY7MSIiIiIiItKxGnl656/xaZ4iIiIiIiIyl2lkpO8XwNNm9iDwt2JhSunipqVKREREREREOkQjQd+v4qdP/IiIiIiIiMhcYo5BX0rpNAAzG5hS+p/mJ0lEREREREQ6yhzv6TOz1c3sPeCH8XoFM7uy6SkTERERERGRz62RB7lcAmwC/BEgpfQWsE4zEyUiIiIiIiIdo5Ggj5TSryuL/tWEtIiIiIiIiEgHa+RBLr82szWAZGZ9gEOJqZ4iIiIiIiLSvTUy0rc/cBAwCvgQWDFei4iIiIiISDfXyNM7/wDs2glpERERERERkQ7WZtBnZl9PKZ1vZpcBqfp+SunQpqZMREREREREPrf2RvqK+/Ze64yEiIiIiIiISMdrM+hLKd0fv2d0XnJERERERESkIzXy5eyPmdm82ev5zOyR5iZLREREREREOkIjT+8cnlL6r+JFSuk/gRHNS5KIiIiIiIh0lEaCvn+Z2ZjihZktQp0Hu4iIiIiIiEj308iXs58IPGdmz8TrdYB9m5ckERERERER6SiNfE/fw2Y2HvgKYMAR8d19IiIiIiIi0s21Ob3TzJaO3+OBMcBHwG+AMbFMREREREREurn2RvqOxKdxXlTnvQRs0JQUiYiIiIiISIdpL+h7LH7vnVL6RWckBsDMpgH7AB/HohNSSg911v5FRERERERaSXtP7zw+ft/dGQmp+EZKacX4UcAnIiIiIiLyGbU30vcnM3sKWNTMZlXfTClt3bxkiYiIiIiISEdoL+jbHBgPfIv69/U108FmtgfwGnBUfCF8DTPbl/jqiDFjxlTfFhER6Tjvv9/VKRAREfnM2gv6rk8p7W5m16aUnmlnvU/NzB4HRtZ560TgKuAM/GExZ+AB517VFVNK04HpABMmTNCXxYuIiIiIiNTRXtC3spktAuxqZtfi39H3iZTSnz7rTlNKGzWyXuz3gc+6HxER+QJrdHROo3giItLi2gv6rgYeBhYFXqc26EuxvMOZ2YIppf+Il9sB7zRjPyIiIiIiIl8EbQZ9KaVLgUvN7KqU0gGdmKbzzWxFPLD8JbBfJ+5bREQ+rY4cUdPonIiISIdrb6QPgJTSAWa2FrBESulGMxsGDE4pNaXGTSnt3oztiojM9To7aFJgJSIi0hLmGPSZ2anABGAp4EagD3ALsGZzkyYi8gWh4EpERESaaI5BH35f3UrA9wFSSh+Z2eCmpkpEpBk0DVFERES+gBoJ+v6eUkpmlgDMbGCT0yQi8ukpuBIRERGpq0cD69xlZtcA85rZPsDjwLXNTZaIiIiIiIh0hEYe5HKhmU0E/oLf13dKSumxpqdMREREREREPrdGpncCvA30jb/falJaRERmp2mbIiIiIp9LI0/v3Am4AHga/4L2y8zsmJTS3U1Om4h0R3rIiYiIiMhcpZGRvhOBVVJKvwcws+H4fX0K+kRERERERLq5RoK+HkXAF/5IYw+AEZHuQKNuIiIiIl9ojQR9D5vZI8Dt8fqrwHeblyQRaZgCNRERERGZg0ae3nmMmW0PrIXf0zc9pXRf01Mm8kWmYE5EREREOkibQZ+ZLQ4skFJ6PqV0L3BvLF/HzBZLKf28sxIp0lIU0ImIiIhIJ2rv3rxLgL/WWf7/4j0RERERERHp5tqb3jk2pfR2dWFK6TUzG9u0FInMrTSCJyIiIiLdUHtBX7923uvf0QkR6dYU0ImIiIjIXKq9oO9VM9snpXRtvtDM9gZeb26yRNrRkV9BoGBORERERFpce0Hf4cB9ZrYrZZA3AegDbNfshImIiIiIiMjn12bQl1L6HbCGma0PLBeLH0wpPdkpKRMREREREZHPrZHv6XsKeKoT0iKi6ZYiIiIiIh1sjkGfSIdQMCciIiIi0iXa+54+ERERERERmcsp6BMREREREWlhCvpERERERERamII+ERERERGRFqagT0REREREpIUp6BMREREREWlhXfKVDWY2CZgGLAOsmlJ6LXvveGBv4F/AoSmlR7oijfIp6OsYRERERES6ra76nr53gO2Ba/KFZrYssDPwJWAh4HEzWzKl9K/OT6KIiIiIiMjcr0umd6aUfphS+nGdt7YB7kgp/S2l9D7wM2DVzk2diIiIiIhI6+hu9/SNAn6dvf4wls3GzPY1s9fM7LWPP/64UxInIiIiIiIyt2na9E4zexwYWeetE1NKM9v6tzrLUr0VU0rTgekAEyZMqLuOiIiIiIjIF13Tgr6U0kaf4d8+BEZnrxcGPuqYFImIiIiIiHzxdNWDXNoyC7jNzC7GH+SyBPBK1yapRTXyxE09lVNEREREZK7XJff0mdl2ZvYhsDrwoJk9ApBSehe4C3gPeBg4SE/uFBERERER+ey6ZKQvpXQfcF8b750FnNW5KRIREREREWlN3e3pnSIiIiIiItKBFPSJiIiIiIi0MAV9IiIiIiIiLUxBn4iIiIiISAvrbl/ZIJ+XvmZBREREREQyGukTERERERFpYQr6REREREREWpiCPhERERERkRame/rmFrpXT0REREREPgON9ImIiIiIiLQwBX0iIiIiIiItTEGfiIiIiIhIC1PQJyIiIiIi0sIU9ImIiIiIiLQwBX0iIiIiIiItTEGfiIiIiIhIC1PQJyIiIiIi0sIU9ImIiIiIiLQwBX0iIiIiIiItTEGfiIiIiIhIC+vV1QkQ4P33uzoFIiIiIiLSohT0NZOCORERERER6WKa3ikiIiIiItLCFPSJiIiIiIi0MAV9IiIiIiIiLUxBn4iIiIiISAtT0CciIiIiItLCuiToM7NJZvaumf3bzCZky8ea2f+a2Zvxc3VXpE9ERERERKRVdNVXNrwDbA9cU+e9n6eUVuzk9IiIiIiIiLSkLgn6Uko/BDCzrti9iIiIiIjIF0Z3/HL2cWb2BvAX4KSU0vfqrWRm+wL7xsv/NrMfd1YCO8Ew4A8dsI621bX71LZaY1tdsU9tq+u21RX71LZaY1tdsU9tq+u21RX71LZaY1vNtEib76SUmvIDPI5P46z+bJOt8zQwIXvdF5g//l4Z+DUwpFlp7K4/wGsdsY621Trp17aUd7QtnW9tq3tva25Pv7bV/fepbbXGtrrqp2kjfSmljT7D//wN+Fv8/bqZ/RxYEnitg5MnIiIiIiLyhdCtvrLBzIabWc/4e1FgCeAXXZsqERERERGRuVdXfWXDdmb2IbA68KCZPRJvrQO8bWZvAXcD+6eU/tQVaexi0ztoHW2ra/epbbXGtrpin9pW122rK/apbbXGtrpin9pW122rK/apbbXGtrqExfxTERERERERaUHdanqniIiIiIiIdCwFfSIiIiIiIi1MQZ9IE5mZdXUapDWZ2SJmNqir0yEyJ0U5aGZqc7QAC12w3w7JP6qXW4PO46enAriTmNnAjtyWmY3q6AxvZgMaXG/+jtzv3K5eRWRmfQBSN71pthmFZRPyY7cs0BtJ15zWae99M1t8TuuZ2RDgEuDvc9hWj/g9fE5p/iy60zkysz5m1reT99lQHdqR5X931EA+GAyQUvq3mfVoNN90VP6awzWydkfso5m62XW2aAqdFcSb2XLwSf75XAGnmfX/tPXy5/2cnX3+OrtzpYs6APp2dPvKzPp15Pa6IwV9ned0M3vWzL7cyMpzaCQcBNwEbGVm87azjUYap/NkL88ys2FzWH83YMc5bTdbv908Zmb9O2pb7a2XNX6HmFnvBraxUqPpSin9u87iA83sZDNbONvmbOcj6wEf19Y5z9I+n5nV/W5NM1vAzKbOKa3FV6IA7RZu1WOY/V9baRs4pwLYzLYxsyXbeb/m+DSwvfYacvua2fGfNvhq5Jqpl678/8zM2ljnk2PY1mczs9HAy2Z2tZmNLNark67dgEHAcsBxsU71nI0EFjGzNYHbGgwO53ht5D5rpWtmg81srQheP5csSN4fGN8B2yuOxeAGVt/bzNbJ/y/bzsLxezVg+wb33UiZvYeZbdXAemPid91rN1vvU53zemmMAGABMxvbxr9dbGYfmtmqKaV/txUwZOWhFdv9NGmrbOuT7bdzvS0DnGZmV5jZsu1sq0jXhmY2qrr9ZjKz+Rsoc75sZiuYWd38n6V/AzPrlb1u8zO0cX4WB54xs0vMbJ6i7pvDdoZU05u9t6qZLd/W/8Y6fYBLzOypyD91A8726tfs9UjgPTM7pL19VrVRxzd6vfaJ9K5pZg2VA9n/1jsHveP35mbWu85x6JudlwvMbIE2tv2py2AzG1pveVZPHWbeRvzMgWCD53EB4F0z2/9TbHdpq23vFsvnM7Oesc0p1nYbq6gX+jZYN3RLCvo6z+nAo8CdZnZGvQvN/HsK5zGzfYCT2tpQSul84E7gUOAcM1vN6vRQZBfiRu2ka3kzu9/Mnol/+YN5T2y9wqYn3sh8JV632WC2COaqhaWV38O4npl9HQ80d28rcebmr7etOuuOa2u9bNmBwA5R+Le1nSWAaeYN8JqCN7vwlzaz48zsOTPbu5pm4LfAvMBJZrabZb2L+XHKKvPdgYn10pOlfT/gEKsfOI0CjjOzB8wb+Xla8rQXDeQ72quAskrj8Hj9rzrbs+h57QvcVBz//H0zG21mJ0VFcAzw8ywt+Xo9omJc0MyOjs8xObbdVl7bsa1KCPghsC3wkJltUj0exe/snAzKX1dFxbCeme1gtSNxxecotnsIMLXyv8W+imN4jZktUm8/KaVfA0vhZfNzZnaMmfWsk647gd8ADwND4n+rDbAl8TJiOvB2vo3q8YzzOAwPOFevl7bsf3cys6lRjg3MlhfHoLjGv2Zma9SrxPGOoyOBncxsOZtzp0J/89kN61beXwBY18zuAA5LKb1YOQb1ttnPzMZanQ6zyIf/jkr9Qss6barbNW+MzgtsCbXlTpTHK5vZN4FbgV+3la7sM/YBBpnZiLbSHv4OTLYIsNrY5tZAzbWbvVecn1XN7BzgcjPbaw77/CQIjuu0ONe9zWwz80DobKAoM6v5ayrwTeBJM7vezIZW82uUJyk+10lm9qSZHWBzGL21Nkax4zyOMLOHi+utTl78AO9E/SdwRZQ9s5Upka7+wHbANsX2K+nI67bJ7aS3poPF2pmibV4XnVott4o0xbIjgGuAc4CpZnZKfkyK8sO88+E0YHDxv9k5sCz9E8zsBOB4M9umchx+BmyCdzg9a2aHVrdTSf9qwC55eivHaxPgSDPb39rocE4p/R3YGHgKuMU84Fywmn+y4zHezA42s9Wq+0wp/RYvn3cwsxfaqBvmWMdn2yv2uYaZbR3/0zfb5kDgFDM7Cm8D/jKWz9bRku23n5ktamaDq8fVvO7Z2My2BK4ArM6xX8vMZpnZdGBYSul35oF+tZxotAweZWbDouw9rN46mV8Aq1iMwuX5IctfI8xs3fgZm71fzTsHxnnsmR3noi79HXAEsJv5YMoG9bYT+9rIzCYAFwL/qOzD8I7CQ4CZcbz+2cZnW8a8vrkN2GwOx6H7Sinpp8k/QI/4vQswAw+a3gQOzteJ968Afgrs2Ma2emV/DwROBp4GTsEb9L0q+1wf+Hfsb4Psfy37ezLwB+B7wJrZ8pWAUdnrk4EfA1+bw+e9CDgfeB1YrI19Pg98DS/Ij4plI+ps6xq80fohsHw76b8VuAdvBK9T2UbP+D0ljsNHeANlA2BQnX0OifevA/q08RkfwoOKa4H7Ytmg+L1R/B6JVzBXAd8oltfZVk886HsZ2KKNtO8MPAP8CLgYH+kZUedYPIoXbPcAi+THC1gAOC+O+Zt5Xmojv24QeednwJRKXrViv8DlwMXx9xhgH6B3vO4N7AT8GXgD6F/ZzuDKvu+N83kj8FA1z2frXQBcUbwPLFG9RvAOiufjMzwILF1nO/sC9+H5dW9gTBvH5B7gyfisM/CG4jz58QfGxflZKF7vVOTF7DweCMyKv/sBq2X5ZnO8IhsQrycATwCvAVtX835s60fAHfh1smKddO8C/AQvV3YDlo3l2wCL1ln/IHza6LzVvJWVJ98Dvgq8DyxWnOtK2obggff4eL0ofj30zNbZNo79Y7G9se2UKXfiZdzvifIilvcBVgE+Bp7DK+/lsvfXwPNqz+z1PcClwO3Mnv+KtN0AnBV/jwamtpGukXievQmYP/ZleN4eF+fv18CJwKrZ/30F6J/try9wF3Am8ACwZFvXZfx9Bl4utnUNLwo8i5cVA7N0DcnWeQ4vD3aLPHQvsHGdsmdzPGC7Am84LZmVKQMij72LN/j6VNLRq1gGbAVchtcLfwZOayPt9wOTgKspr5W+ddbbKdJ/A3BoW2UZcBawc533is+3Vpy/O+P3LGCnNra3Ol5OHxqfrWeddZ5p6/8r650Vn/FqYOU21lkC+A5wdGX5GnhZtAxetg3Hy/e18Dpptv0DLwCbxN97Aj8o1iPKsvj7+UjTsZHHvhH7mwrsma23MfBI5LNN20j/hnhH32F5/s3eXxqv2y6N/LVDfkyprdsuxMu5mZH2o7P3inO5FV6enAn8H1mbAlgB2Cx7vQ/enrkDWLxO2tqs4yv7PAy4Bb+eHsfL9TzdY/AOuv8B1q7sY3Sd8/oU3p55GTiyTnlzNfAX4IZ2ro2DY3/PE2V5LB9LVuYxhzIYz+ObxPH8EZXrjLL8Kn7Ph1+P91OnPRfrzIx03YTXuzsDQyvHdBRwPfBWnJ+t8mu6sr398TruVmBc5b3F8c6vnwMz2ygfFovz9xfgKLxO7hvvL4l3cAzEr/mH8Xqtbjthbvjp8gR8UX7w3vsfAwsCI4B1gVeBl4jGQFxgl+KNqeOBTSkb9ttRNgbnx3vs1ojXi0dB8EKsV1yAPeJC2C0urg/xBk+1oFkKbwTuEmm6LZY9SW0DamE8gPkZcGBlG8U+d499LI33oi4YF01eWO4MXBB/v0HZ6D2aaDDH613xingwXmguhDeU8kJsHrwCmBjHYUqkuxr4DQe+j/fMr4gXYq/hI6rj4ljlBfUAvBI6m7LRUnzGNeMz9sYLr+Vi+bnx2R7DK4qiwbsc8PU4RxfghUxNYRl/bxvrLFKcv/g9GG9ULRhpPwgP7i7EK4kiCDsp8sX6eMD6Md6wGJDto2+k7wf4tMAvx/IReCOqSNcwvBG6HR5c/ATPq+jdIaMAACAASURBVCtWjuu8wDPx91Z4sPYBXugPztJ/Ld4T/TZlY3oPskoE+DLwQPz9KLBW/H1efj7jOLwZf4/BGyaPAUfk+RFvfK2FN9ovAP4Lv77WBRaM9V7C89lhsZ9z8Osgz6+LAZdmf2+PN6bvAb6SrXcScEz8fWrs/7fAhtmxfwmvuMfjjba/xDnvhV/vj+PX3xbZdncF3sEDiPxc9o5zPyr2NwvPg0OzddbGG4M7A9/CG3BHAH/Cr4lelfPZL9JzWRvl2KPAsnhwdX0sWyWOSR6UnI9fO73wIP4/8GB5IcoOgSPw8uRbwLfjHK1HWeYV+X8zvGHbJ47fCtlnK9aZgDdCz4r8sAfe+Dimkv7n8c6MK4HLY9ky1JYpI4Hn4u9N43y8ize++8XyRSiv0xH4tbReneO1Gj4SeCzeiDkYH7G/q/IZL8WD2j2zfS8ELJBta/7sHPXEg/NvxN95J0yxzSF4sLZGto2L8IbUZOCMrN4ZFel6Hdg+W78/fs3ui48MHAvcjJe1xeefF2/w3g/cDeydXfeH4Hl0SbzeKDpKlsIbkR8D62b7WyGOc0+88btKLL+E2k7L/nh5vh4edOwXy8cye0fF2sB7wLFt5OmXiGAXr+OOjc98S3a+B1LWAxPw62y2hl8co/vj757ZuVi0cm72wcvXDfFOgRH49TyY2Ru1y+EB+ZRiG3iH7KV4g/1FYL5KPfIA3gAvGq9D8fJqhTiWF+F58aE499fio1B7A6cU+Q2v646O7RWdLs9R2wG7H16XzqJ+ALJcpHW2TqZsndGRnmvi2K5Vef9Y4NtZOboBXoe9R23H8mOxv6nAVbFsQ8qg9XW8nPlSvNcHr0d/hndI5J1D91K/jl89219f4PmszDsp/l4Xv+5Xi9eHxM9v8E76+eNc3IfXZ7vGepfF8RyJ57NZzB7wz4e3Te7Hy84i714C7BZ/L4nXY+fgdcxlsfyROB4NlcFZPrg8zv3JeGBelNHr43lrdH7u8UDrsOx1cVxXBqZnfx+M58VLqG1rPoS3cybhZeJDsd7S2TrbULaB++Fl4U/jd95xsA7wq/gMFwGbZ/ligyyPTsbr8Mvw62BLvIOzaMf0x6+h7+GdeJvHsnli/dk6NbrjT5cn4Ivyg1c8MyrLDogLrWh49wFWjQv2JDxgOwovlN7K/m/JuOivwhurY2P5ZsW24vWBRCM6Xg/Gg7oPicZ2ZNwjKSu0Ufg0hDeAi7L/nTcyd6+4QB7HK8vNK5/p3igAzgTOi2Ub443SolHyJbxwfwSYHMu2Bl6tbGsGHgicTRkkbh6fvag8NwFuib+LguUo4OuVbW0FPFxZdgweIN6JF1xD8GDpq3iBtB3egNyB2h7yQXgQNx04MZYthFdC88fnOwZvqJ5JNNzwiuoist4ovLF8Bt4IWouyNz1v3K8BPFJJ+yF4AXQd3qgfgjeCVqx85r/jPWp5g3xM/M9leCU5Fa+ILszWORn4Vva6Fx50FIFkXqjejAcl9xIjxXFcR8Xf/eL49sYrulvwwvldouGEN1oHxbmbDlyZ/e8PgIWz/S2FN8QvwYPME/GC/QZiJBFvrLxA7cj4ZOC/43z/Eu9BnJa9vypeWV0PLJMtfxFvgFqWphXxhnAeYK2Fd+y8CRwey44kRkHj9ZV43n+U6NWOc5BXeIfF/q4AVsqW70xtvj8Wz1/FqNzacTzWzvLIN7P/748HQ8cQMwkor5k94pithuelx4D9s3NTfPZj8Dz7InFN4OVUtWGyE95InIl3RCyHB5NHxPvDqS3TFsMDhg+ozCTAe3LXwxsI18ayRfEG06BIa5HXxuAdTxfGMcyvo8WBq+PvVyjz3qXA+pWy7ma8IXhH8R5e5hU90mfgDc7r4+8fA7/DO9iKkb4RePk1EC/bt8YbVS8BW8Z2esT7t2XHcvf4e+/4zIvF6wsj3ZfgjbQj8R7snbO0LxXnct/4HKfjwdUm2f4Oxq/X96gNpPriI0t5R9T2RL2FlwEL4vl3SuxnNWoD013jmN2F1zUHxvIVgTsq53UTvAxbOVvWDw8yZlDOHhiClwH5fnbAA+3BwMvZ8vOyvLBJHPeiY+R8svox+0xXUdvJMg8eBG2aLTsOD3xOwOuFt/DydkJso7g+lsev7WHZ/24MPFm53q6JY30YcG6W3iLg6oM3dpfEy81JeACfBzjD8PrwJbysK67prfCAYEmyET880Pwlfj32i+P6NmXdfyTeNviA2sb1aGCb7PXp+EjtzZQd0SOAr2brDMFHRYuOz4uB75LNyIjl2+KBTTEDYeU4xvdQ21mxC5WRYbxj/JTs9SC8nbEafp0UgckdwL5Z+XA5XjZ8vThPcazOz8q7gXE86tXxQyrH5jy8zHmpUmecjee7zaidQXVuHL8X8U6CVYD/xeuNb1MbcK2J13XzRLqK8r847vvjnYtX4df5ULz9cSBlwD8az7vvAjdl2263DKa2zbAwPjvhELxeOg5vo74V6boAHwG7ILZxCz6jap/KOXuIrB2G5/OJcS4HZuX089k688X+HsTrt2Xxa+6bsb2jiYGM+OwXV/a5NN4uWz7WvSaO129iX2Nim6Niuzvg+fWB+Ix5eTh/HOPjiHovzmPNPrvzT5cn4IvygxeKb0WGK3pZTiIbMYuLaZ/s9RLANLxR8ZU629wOb7Dcj1fygyrvj8cbJcMpK6Wt4n8eje0/R1R4eKN1k7jIBlBWBuvHxXU33tDaM5YfThSU2T73jIvx2WzZQ3jDbD3KntOzopCYGumoN7Vxmzgmz2TLHiB6deP1YLyAn5ItOxi4ubKtAXjhuR9lr+sueKP5abyAXx4vLO/CK8an8ALwvbjAL6QcZTgND6j2wSu3B5m94btKFB4Pxnq98IbVRngjaGictyvwSu5svOD+CK9Y+2RpL95fPpZtH+fxeuCAWDaNrHctll1I2as5ID7nVKK3MtJ+HtmICF6Ir4IHUXmBtwfeSLkOrwAXpwwwtqJsRJ8M3B5/T8GDxZfinO8Qy1ei7AXNK5cj8MJ4DzxIvgM4O3u/COp2wAvuopfzUGZvVE4nej6zzzotuzauBP5G7ZSlgZSjC/lI07txbvJe3n7Z36fG7+UoG1/j8BHSB/EAaAn8Wjw6O/7bENdK5TgMi/P9JN6QWShLzwqRlr3wUZEfA3vEe8Vo0Dx4QDAcbwwdj1+/+Uj6wXijtTcenJ2O5/k7Is1/oiwbeuENuTXxUbunYvnm+PWXp300nrfPxzu2ium2r1Hm35GxjynUjqo+hI+8TaTMT8vgPfS/zdabgef3c4BrYtko/JougqT+kY6ip7Yv3lD9JeUo12p4Q6464jkozvvYeH0OMbIZr8fgDZat8HLtWPx6vDL2uTrldOA3iGs0S1dPakcXT4jP+Fi27E28jrgTb1T2w6+5ZfEOjHPw8uVn2THYLM7jHXgj+4Q4jzdmx2ExvCy4CJ+SeTrZtOvKcRiHl395AHQQZfBscc7epGzgj8Cv31PzawXPY7dQ1n/TqMwYieX74T3ze+OB8n3UNu4HU07TfZsyj+5JOetgCTzonImXkd+LdX/E7IHfdpEHTohtr4DXi9fh5XMfvMxeE+8oOxgPCp/Cr+sj8bzVI36uxuv5XfHr+FlgUmWfu+HX4w8qdVsxOr4enpfexsvwmfg09Wcor6GiTl8w9vUYHrTNwoOYNfB8ujZervbLjn0/vN47INvOwrHvGfjUwHx68z3UBrfz4QHKHyhHt3oT0yTxsukmfJRsBn59/AO4pHIcxuL1xRN4/VB0LK9fWW9xvKPwJmB4LHsyPvdR2bKv4x2Tp2fl6+vMPpPny/g18h2i04Ty+lg7jt9F+BTRvfHr+aHY1yeBF543DsHbMvvE8q8BT2T7Og/vMDqCsjyZL9KQp+kwvFPyyew4L4OX70W76fBIx+VxjIfg5c06RKCOd6YXI9/LRtotzm/xGQ2/Th/Er5t6ZXDxOc8GTijqKLztciKePydl/7cI3nG6AV6mnIaXQXnwvh1enjxLbUdb3jk3ON4/PVu2GH49Xkp0RsbydfD89RBebhSBY9G5sie1AeT8eN2yJ173zIPX0Tfg18+07Bjl9XsfvA23T/x/LzzAPAwvD2abudVdf7o8AV+kn8hw0/EK7frI/CPjvY2A1+LvEXiBc3y8znuWzid6ieP1PHil+O18vXivb1woD+DB3ES8cl4EbzCfj89RHooXbG/Fdoqe5iIjv4UPdS8bF/VNxcVO2aAbBmwR63wvPuPGcRE9QVnwnYX3Ri+EV3y34SNE+f2NQ/AG3Gi8sit60C8nG/HCe7m2x4fzP4jtH4JX7PmIV1FgroY3fr6JF/g/iM/zy7jgJ+UXevzPCnghPis+y7V40NQbr1SfiHQdl/3Po9ROW9wSv3/oLrzwuAKvcPem7KGaB6+IF8IbknfhhWfRo7c4XvhOj3P2ZqTrIbwA7hlpfTm2PynO04zsPF6CN1Qui2MwjQgIs7TmFdrNcVyn4I37n+N5cyYedB0Q+ziU6MHF89b38YZIX7zSXyqO815xvlev7Ks3XjFNiuOzHp6nr8YbVXnFeG+dNI+Oc75IZfm6kZab8YbFe5QNxGXxwO/gyAffIaucivwf56QIvg/Hp7gU10yxfOFIb36d9sUrvvPw6+J0PO/tRjnFbVScrzWy9B4bx6m4b2o5vFNncrbta6m9n2VjvLcxv/92g0jTonhgcEX8PgfPKwPxxuQDeCM+r+BWxxvNU/FreSw++v0ink9XxcuvD+IcbU9ZyW5LTMOqHMsL8aBvQ8r8uCNeDm0X6T0xPtuisf1plCNiG+MNq0fxiv+pODcPx2fZNv7nffxamy/+72a8cVI0lJfAO3BuoSyT9or3esa6p8b7xUjBkngAMR+e/4/FRzynVD5jv/g8F+LlwkQ8IJiFN9ZfIO7NxBsLt+O95z0oR5fuxvPKFZH2ZfAA6kL8ut2wTh7dDx8peJXaaXeL4XXOeDwPPRrH8TfUzrp4AA8Wqp1uxTW9N+VUsqLRtmZl3RXw4PM2fIQxv2Z74mV6X8r7s2/CG+PFLIj+lPXFQnh5czdeD1Y70y7DO432xzuTTsXLzLep7ZQx/DqdF2/8T8bz/0Xx/lKR7vF4nr4K73C7N475jpHGmdTej1kETsvEeb088sZpeJC1CH7tPIDnz2lx3P4nO/+D8PLghsgLZ+Ll0Dt48Pml7LgsQzmCfTblzIYL8Qb+7pH+xfFrvMjPxTneM9J4Pl7GLog3rKfh18NX8Dz+HmWZvGx8tv/DpzjPg9d3fwR2yY7Fqnh+OgCv5/6N1y3V2xaKmRFPk82uyD7jinig/ATesC7Kk6FxPMfjeeiKOEe343ltG/yavYyyrJiMd0zdG+euOOZr4oHXeZSj91/D64gjI5174fm4aNdshXcAXMLss4cOw/NIb7xM+hZeH8+k7NDcKc79bXjnz614fVrMziiO93FxLAfi+f5veEB2BnE/WxyL5+M47xef46LYRxGorIOX070j7S/gbbp98jyRfYYd8PZTtQzOy4f3Yt89I507ZO/3jmOwFR7E9q9sfy/8mh9EOQuoD17vvoJ3Joyqk66l8fL8frxN93jsd5c4r1OonW10An77Rp43Db9+i9unemf7L9K/Nz7y2gPPY5fhefDoyvm5GM+f1+Jlzg1kZUK+bnf/6fIEtOoP1DyA42I82NkWrxyWxnuT8ilrX8d745fFC7Yi822FF5Rr4YHVAXhj7jLKKRFn4pVMsc9F8AK6mNKzB97wuBwv9BbEg4Yv4xXHY3hBPRxv3N2fpWsh4J7sdV+8d+1WvCLYAC94HyWbfoEHAo9Geovpq0viBfTjeMG+SCyv9rJfSe2I5xZ4ofo1ysbwDnhD/+q44M/GC4ivx+eqPoTgQbxSHIQ3xnbAGw7r4A3vU/BG1gXx/shKmn6FVyY7xXG8msp9g9m6W1I28taNZUOpDUTXwwuv++OYD6EsYHriQcqzxANN8FHIxfARuK3xwng9vIA/Ce9RWxlveB6P57mTKe9dG0s5GmB4J8BJeOPrq9nxGo9X8lvEehvE/s+L9b5E2TmxEN6IOAevFL+GN7CKBvduZCMXWT6/kXi4RCy7LvLEDDwwmNTGcd2P8ob6BfB8vQPecJsYy5fFr4XTYnkvvIKYDGwb6+yC583X4hgdilf6v6J2ZPA4vJC/l3KqY/HAjaPxRkzRML6S2ik8w/AKdKl4PQDPO5fhjcsd4/gW7/fHRxOn4p0cd+EVY72HG+2FBwY9svN2M+VDGXrgeeiK2NbUWL41cHdlW+vilfIs4l6sIo9k290/tjeN2vs0RtZJ27vErAS8Qv0mnrdXxYM5w6/FYtrfjvi1/R28IVdMzVsTz8fFVKJl4hjtHu8tHNucjuedB7L9Ppsd19F4w+gJPO+Nw6/7LfEG1WqU1920OD9T8QCqDx7kzUcZAH470nUfMVUKz4vFeTgVb+BdHsfsLcr7iJ+nHBWZJ/b/ZJzLJfBra0s8L21FOX12BTwgOozyKY1FQ2ZgHMNH8Tz8pzgWC1XOy5h478+U92Lmveub4B0MPbO8ch1lp9MKsf1LyKb6VfZh+LX1d8qOw8PwsulGPFgegtc/i+LXSF4GnBrn6el26tXFKB/gNDCO00WRT4rG/d54fXAn2YMw8OtiAGX98z287nyZcpRkRKyTTzn9Ot7hdWOd41oE6CPxxv59+HU+us4xnoyXMU/j+XAA3uFyLt6htHjkgZvimB1INn08tjEYr/c+wNsTB+KN9qvwfDqQMj/ngdey2fk7hfIBU4vhefCvxCgctY3pjfG6ZyCen3fC2w6PUGn0ZtfC/Xjn2BF13l8Bvz7Xqpyb4raRmdROh58V6f0R5QyjkfFZe8f/rRzH8Xq8nTUaLyuWqhz/ZyJvPEVM2czK3sHx3m8ifyxX+d8F6nyWXcimo+PB8+KUMw22jWN1Ll7H3BY/L+P5rzhPw/C8lXfarYR3AuSjVKcSMxSydQ6Oz120i4oZFk/ENlfFR/8fo/aBW2viZc0EfPTyG3iweXslHfvh+X8o3jaaGeei+MzFLRYP43n2FGBC9v/74GXmpvj97ZdRzrQahZdnRd09b+xrSpzT5fAOxevxNt5deOBc3B99LmX7yvCO/Pze1iF4/VWM/hVlzbdi20vheXWXIt/j5fK21M5SGEfZ5nk4zuWVZLdxzE0/XZ6AVvzJMtd8eCNoIj6EfBfeCFoPDz6Ki365WOf7+FD+ZrH8Erzx+jzeaLgNb+ysGMtfiUz7BrXTq76P91TfiTem8odN9MB7qYtRsfXxUcZi1OJxau8D6B8Z/V7KqQmrENMX8ODySbyXZdtIX6/s8xeNiLzAWTGOxV14oJCPMmxE3NuHF+4XkT2tL1vvG5QNu3Xxgus0vEGWP8jmJ3iwcnqk8YqsEOiBF4in4pXZInjD7+bY3jpxnvrjQVRxjEbjDeHpePC3Yra9vKLdB5+SchteGc429I8HzI/hlfbaWdom46MWk/AGzBt4Y29s9r8T43gtEun5Dh7Ej6rsw+Lz/x8R+MTyBfHALJ/y95PIO1fjQdiG2Xt98AJ3h8r/LI0HhW8C38jWPTq2dxNlI3UzPIjM74+7NPvcG+GVx5tkN/PHsX04PvMmeGXxEn6N5PfVPYI3bu6NY3YdlSez4ZXuMvF3MT3kyDiOxX0Qy0QaRuEjTJvG8oWy83Z37H8DPO9Nx6+ph+OcHhfH/kLKBmmRd24gehhj+bRYfzgecOyGP+Dhzvycx7or4w3HU/GKf/tIa9F7vGccpx6UAfgieFm0It6g/yllz3g/vHPqdrxCLMqfXni+L6ZZLoc3nK6j0hiN98cDd8bfZ+LX0eNxjPLyafs4pi+Tjdri11m+Xl+8cXgeft3uRdmYXh2/ZnpQ28g+grJjIN/WKvHZZuJBUrVHuh/lAziuprzneQfK+46XBr4bfz9L+aChfSjz00C8MT8cb+DejjdOl8fL/p6R5nxE5So8z0yhnJ47Is7hKnggUYwGbox3JtwS+308Ptfi2Tmbjj+8obhXrCfe4XY5fq09hjdaivSfTvbUzlj2AuVoRTGVfKV8nXbqv354Q7Y/3sDeAu98Oy3SfSi11+xSlFOc76XsnNmLyhN38Xz/OlnDMj/XcY7ewDsmt6SsZ0Zm6z6LN4o3j2P4neyaXwovh9/Br8lxWV12Ld7gPS2O8wJ4PtyL8uE1k+Jc3hD770NlBIDy4RoXUdaPnzzVNl6vGef9TrzMHIqXJYPj8303W3cePJ+dWOdc9Ky8Xhsvj6Zmy0bj7Yif4GVh8ZlPorx14HJqp9iejI+I3U1532QeLK6HBy0/oXyQ1Yg4f4/gwcZ7eOBdlK0Wn7coYyfjnctFJ/UYPG+tipcN1dGh8ZGuG/FyYIlsu9tR3if+FmW5eATeebcIHiRMo5w2fSjenplKnWnI8f+r4WVTEXSNxevtY/AAp7gdZBje1jk9jld+r/k0fAR17TrbL+45HBDn5u/UPrCsT7aPYiRrU7yML8qSW/FOhZ7ZZ74Fv8bvz9JnlLOiivp5Aj4y/wPKEeSj8TJoccq22qN4mX8vXr4UU2bnpZzZMgKvt9/G667BlX1djwf5d+Nl5QGUAwNXUI7o7o+3O4+P7V0f+z++mvcjLzxDlBd42f9MfNYv422I94gBkuz/8vOzBl6GrQ48ntUnN1LWO91+Wucnn6erE9DKP3ivx6FxcbyIF1av4j2xRSOhNz59oGiwFZX3ZvhIxAC8l+PtuCCKC6Q/XsFNxhtjRaC1GuVTqxaM9x/AC/VRkaHHERVdrNcDr8R2JbvRN3t/nvgcz+K9Nk9T2zuyId7Ddk38XisuikfwSqpPXCA34Q2UokDYK9KVX2DFiOeXqB3xzB9ZvyX+vUrHVdL4VWK6VCzbpDgW2Tq341NQxmfpP5/ant018Qo+73GcjhdobxE93Xij7kTKr2jYOv43nx8/FW9AbJqlaxJe0ZyLVyqDYjvvUDa0PnlATbwehTe2f0NZgBneuBxO+XCRU+L8VJ9aOCT28V58lrwRVFQGG1PO3V8OH0mbTtnZYNlx/h0xapFt5z48jw6kHLFZCW8kzYp03UcZrPfCC9PL8Q6DIvDrjffcVqdx7hnH4DXKBuuz2fHfkfIJb2/HufgOPn23aEjOH+dxYrbdonc6D2Qn4/lzAmXFOC+ef4qKeHik84b4bC/EOV2bctr2QHy04268cV+Mzq9GOd2lB97LPDKORTFidzKVe2az9I3Dg6p78MpwtyyNl+DX4lH4dTgYr7COz47vznjjeUZ2PhbEGwePU1a268X2ipHm4XiFvWWdNA3Fr/lfEdNy8ev4wWyd/Fo/AB8RuJ/ZRzSKYLZo0GwTx+aS+IwHk90nF+sUTxweS9lBs2Acq2K63ES8PJyJl595Q/vEWP50tuw1yuB4NF4m3QpcF8sWwhu2C2flcv4QoJvxgOn1yAfFkzb74vluXCxbJfLIg3gnQvGo8Z8RX1uQbXMMfm0uEevdiXcW5lPklyALDmKf98X564uPMj6N995/QO2skzXjOK6El8UP4nnxjDwdDdR/J1N7X844ymm4K2fpWhTvLDmQuBc43nudMm8W9d5KeB30A+p/DcOplPdrGh6sXUPtfUVj8DJ/BB6UrhTLLyJGn/B8WzQmD6Asm8YTT3PE8+C5eECSP+ikF9459hi1HZoLU96TPB8ejP4l26fhdciulOXbAbG/WZQPGumNl0N7UI5ATyQeBtTGucg7QAZl6SjqpOIBRWfjQUvxRMuT8XvkPiqOQbad+fHyrzg3PfHyMs9LxdTj22PdJ/EArAgm98frpLvx63JG9r8H4dfFCcA5sWyVOG5Fe2fVOEbX4B0bxTThqynLxOI++jPw8rKYtbEJ3kG+VaxzJOX93NviZc2V+FTRL2WfcwW83irWPRPPR0UZswHezvk9Wf6P995g9qnRxVPRP8ADwLpfw5KVg4/Hcdw4P394mXs93pExGK9XNqW2g6D6tNHiwUFrEbOC8jyDB4O9KGdrTcCvvZGx7R3xjtNHsnx4H94WOT7bdl63rovfC/oMZUC4NNk9+XhH3qV4u3F9vM1xD16XF8d5ZLx3BJUOD7zdPJLy1qXn4udhyqm9RbunmDV2B+VTWut10C+JtyeGxLG+9NOUh93lp8sT0Go/1DYi1o0MchzlcPhReOOiKEAOony4hMUF1j/WK/5nabzyuRuvhNelcv9erNcH7zm7LFvWm/IpYcU+98eDl7OofSLaSMrCfym8gX1j/OyFV9r7UHuT77ZZOpchnvqIj+bcG8sPxBs/E/He1ZuIaWLUPub3S7Q94nlI5XPuS/nEyPw+lqIQGRzH6yW88Zg/TW3Z7O82v3sQr4B7RqHwJB7w7IQHFHdTBi03xjGdhVf0R1L2Mu6GB8zFsR+DB/674pVd/r1BRUdAX7zAeyfyx4LZOitnx/6C2Odv8cZHUWBtTG1guDTeOBwZ5/DS+Mxfz7Y7DG+AXJctKx6YsFudY/MVvPH7Ij7lbn+80u4Tx+nXeKVSTAvaEg8wrsSnxQyIY/cmnmdn4AX7J19nke2rB34d9cfzftETvTPxVLx4PREfOTmIcirrFLwizUea96S8P2kEHqS9UdnnKHzE8aPsWJ5F9iRUynstlscD22/h+XK5OsdrCbyiuD+2M091nVjv2DiOy+JB5PjK+72oDZza+i6kLfDe6lsiTcWUoyLoKB75/iKezy6mbNgWI3vFfQ434hXi9bHuD/EHDgygzNcDKQOfYl/zxrndLl5Pxht/N8Y5Gozn9fuofQLlV/GGxWV4L/Pdsa0l8Mbb+nglfRd+PeVlbrXh8micx9vwCrt4cM2JlMH7ipF3ihGPeyh75b9T2d4UvOw8Ms7RDODMeG/ROHez8OmAg2PZ7mRPyYx1i6eL3hH7LB4jfgzllKXqo8aL4HMNvKMtH1lZHy/rnqe2Q6Moz9clG1kuykG8A2olPNDLZ4QcdSVpDQAAIABJREFUF+fgHLxDaX3gxXp5rY3814Oyg+3YbHlfvAz6JFCI37cB/4/yoROXEE9qzbaXf7/Y1nhA/j280W7ZMfsuMcoRy64mOrPidT88UPgD8d1dce7fwsvIPD9tincE3EOlowPPkw/iQdHU+FzFTIFRsZ+irJiM58VX8HKxqNsmUtaFx+Jl6pXUPtBnWJyfAXEOX8bbAUfhwfLpcd63oRxJ3jDPB1nZ0aNy3L+Kd+zNwPPkAnhdcTBlp9RZlOV00Xk2EA+w8+/dvASvJ/+Mly2js31PiP+5Gh/VyjtU++AN87Wo/R7XxfEHDeUPcJqJX3u94nO+i18zl+PXXBEcLkY58rU9Xm7fjQeyk+NzPk/5YLFhsZ378RHO4mnlX6L2toyelNfjW3G+DsVn0dxYyedT8RkVM+M8b0DWARbrLYR3xBRTwG+LY71Hdo4WxvPhUtnx2h8vG4pp1Hfg7azpwKOxrH9sO5+u2d7TRrfO9nkQkQ/xMqA4x3fi5XX+FNk1is8Vx7C4/21/vNz4cRzTTSmnrB9DNjUSz89/oLbzZAG83Vp0bNyIB32fTG+v5u/4vTbeLrwy0js8zuXalKOLV+LXzS1xrnrj+f9H1HbUbBvntzjON+F58kHK+5Hninv5PvlMXZ2AVvvJLppd8EDpOLwAfBkPeH5IPLUpMtpTeMWYP8WzOh1kGvHdYnhD/0bKJ+9ZvNcnW/en+PB4Pr+5B+WjxJfFK71r8cbP+sz+AJPiHpgt8aDnNmZ/iMAAPAAqerwWwyu64nsI38V7VmZSzuMehFdI91H75eFzGvGs98WuQykfG3w9XhieRPl0vHFxPG6Kz7sS5T0q+RPLPvnuwWz5cLyCLr6rr/ro4dvxHr+F8IbgeXjD/5T4zHfG/31EjFbE/12MN7RWpnyM93A8mL4UD256xjE8EK9gTsYDuQGUlfZoPE/1jDScjY84FD3ERT48Eq+YXqB8BHoPvALaHq9oi23uhQeQT1JbqPfO/m9ZvPBcGm/YbIH3yN9AGXRuEe9fh1dgU7PPuRfeATABrziLkZz98IbHRXHO84bXuXhA9QJlADY61q9X+G8Wx3IwPvK0S+X9PniFfDGed+6jtqF8Umx/j3jvG5GGtynvkdwCv3YHVvZ7J+WT07bAGzN5vloz0p2PPORB3Lx4w+hJYnpetWypV0bEsh2pvZF9Hjz/fr96nOJzT8QbO4viAdEnU3hinbxDpj9efiyP59WNKfPYqnhj6Wq897ao2NcnGkJ4h9DPI+8chDcYz8+2vwLeUCjuHcm/l/Fq4rudsmWb4sHVTXhZk4+ufyP2MzG22QMf/duVuMcDr+iLh098l7LjauXIG9/FGy0LUwa/C+LX2z54w734vqbi+pmBB4sbUj5FcjhlQ2My3mk0LLY/Eg9kN8HLk+pTJdt61Ph/UAbWKxBBdbwuRk4excuQYhbHi3hZtEMb9dahePByFeV9bfmj458nnkrbYD04OtK+cZz3t6g8kTHWOwW/Tnvjjblf4g3Y26l9MNIJeDlWjHAVx/QCypktRaP4G3h5fgbesfNjyobjFMqvEiqmub1CdKhm+1ue2qBlzzgGn3yXWywvGvO34/lxGzwQ+zHlNZ8/0GoVvAy8k9p7gIcST/LERzKL0agtKunogQdXf8FH5A6PtO2W7W8Afi0XI5iLkwXM2bbmi7wyCS+7iocLjaS8tnej7EDbJc7l5ZSzdtbBy7c1KUeQRuL1wat43dWTspyfgo92zYhjv0GddI3Ar4+B8fkfxtsGxTToK/Ayekey0Ra8PnoyluedG8VXl5yBlwE34I32Y4vyNz7L0ngAczHeZsnvu8vro97Z8dkqzvnpZLORKsf4TDwo/Al+vRb/OxnP009QBqvFLIyp2fn+Pl7//AMPVhbPjnMvvJ1TzEaZRfksh+KBP5/2aaPzxT6XwMv1Ii8uE+fvZry9sQV+jfeMc/kLfOZN8b2xl8R5K+6ZL+4nPRpv051HOc12TGzzMbwNUP1ey6Xx63oUXk48hbdPlyDr0I11X8TL/6uJryzCR+mKAYFp1N67PYCyw3Nwts8j8OvhFOD72fYHU5Y/c1XAl1JS0NehB7MMWLbFC7biSVu34r2wd5ONWGX/tyk+tP8StaNWxQMZzoltFRdIca/CZLwxMgUPttaN9xeIi/DduDDyAmsBvJIqboA+DW9MHJxl9nHU9jQOjgv3Cmp79o6m7OXeJz7znykrmyGUPVLPU9v7+i6130HW3ojnLnM47sWjc4vvyBuBVyrFMP66UQDcSm1ju953D76IB+cD4v0T8ODqqVinaNA+Rzl9ZDO8cHwd7y06Ai/0JuG9d/nx3wGvsJ6jrAhPxQuXxWKfj1P2qK6IF1IzqO0FOzD+J+8Z3ZfaG5CHAu/F349QflfR8njeWh3v8VuA2qfeXYD3xhbfHVb0oE2K7byKF5onUXY2FIXg3tR+v9+G+OjHO3hwOgjv9NgCn/azb7buOLL732LZ5ngDth/eE1jcO5HfrzYcv+a+iY9Azo9XpPcT95i1kW/mwSuRfCR1WHy2omdvI8rvS8u/A/MFyvyVn4MeeMU6Hm/o7og30t8ie9BKkc8r6cmnSfXJjm3xEI0HyYKyeG97PAApRp2/hff2FtOXJ5B91UB2vO7Ntt8Dbxx8m/L+tSF4R8+VeINjS+rMLoh1H8fLsJOBG7Jrsg+1PcfnZf+zFN5A2DlL04N4T+szlTxQPHxjcbzyXoVyGvTelF+NME98lsPxsvRtaqeA98OvmSIoXx2fLv1fVEZnqe3tzUcwzqQcCc1Hj+fBr9GheDBY5I3zKafv7YxfO69Q+/UPffBy+CLKDpZ2HzWenbc943idT9kh0h9vIA2rfKb98YbZFWRlcSVfTMcbp4dR5tN18nPXzvWUBwozKb/HcD28HP03Hmjn97HekP1/0Yidr3Jsi2tpBH4t3Yfn823wwGAkfo3ciJdR8+Bl9Z14npyKX9c98U6rO7P9LYTn7VFZuo6N/30NrzeKUbmheFBg8TON2kfWb4FfVzeR3SNJ/QdaHUP2QKs4v+fh13P+hOr86b55PTImjsPHZIF85IlTKOvl3fG6622yacdZ2VFMUy46Gq+k9utFXqac2rcpnsefwzvp+uMBbDHydQ/x1QlZvnkBL8OPic9ZdFYMw9sm34ljvHDlM5xD2REzOM7rKpE3Vovz/734bBMoG+17U3ttHYrXq8tQjvqPyI8nfg0VHQG9Il9sTTlCV+Tr5fC20g/x0c+aTvA5XBtforZDrV9sZyBxH3osL2YIFXXuWXiwOhRvX92MP3TnFGq/0uk44ommxWfD21hLZfts72mj+cNXtsTrm0WB57Llt+Bl8L54O+l3kbai038Byk7RPnid/0f8uijuRz4hjuFulO2nS4lOO7xNWjyIJp/ddQa196GOx9tzj0eeGBX5ZnHKTqBXKGefXIm3e/sT0+WpvXd7p8r5GUR8hyV+nRbfu7sdldk3c9tPlyegVX6Y8w280+JiKyqWxfGgbXfK+xuOxCvG/Srbnjcy/VHZsv7UNkym4L08R1L2BK2O99gUc6BPiAv8xcjQ28fyXag8iRJvSOQNpiXwe0Dyfe6BF+oz8YbhQnghOxNvLFt2bG7EGxM34kP5+XevNTTi+SnOxVKUX55+Ft5Q7BXHupjStT5tf/fgrZT3LPbGC5Qr8Arjivis07P9fZ+ysJ6IF77fxXvU8op6dbyAegQvwFfDe7DepXxIzuJ4xXUn3iNZ5KPNs7QPxhtTr8b5LkbYTiL7fkK8t+tsvNH1VCwzsoAzlu0W+eEkykJyoTg+eS/zK1leWhuvgPKGfL9I93aV89Gfyv03eGV3Mt5z/P/bO+8wqYrs73+KqIAEBVERQcWILiomDGBCzBHXLBhRMecsGMEE4hpYM+aACcWcc87Zdd1193Xdn5t13aT1/vE9ZVXf6Z7pYWZoGOr7PPeZ6du369atW3Xq5DMtPH+Zd3kpsoQcTtQ4D7d3FBjkW5EC4i6S+CdEuNuXa7eB+bMB0pSfgW2sZfo+jbpr5kZi8fCZ1s890ZzfFTFojxO1mHsAY8u0XyIUImZlJFaCI9CEQn/Osnm0OVqXM+xdvEF0HQzttrP+P0Nkwtaj1J3uOqS8OJEYBzqeui5jfSkteB6E8ikYfbHPK9oc24boAncOddPxr4u0+e/a+PWxv6+htfESsiA/bNctiZIwnFRoJ3hF/Bsx0+GeDxPdTR1iYM4g1mrqghiKJxEj3BdjfBAzeJ314URKaWHIjvg0MfZqQcTYLWG/dYiWH4M0/9OISqRxmFs+9aQaD++vMD+WQkz3g4je9SMyqr2R4mV7u24BZDH5hkj/QzuLIcZ/Q0TXnyMKPFWvI/ttLzQnn7V5cQmiGSGWrCsxI95A5HXyN/vbodDeeWheb0d013oN0e2eyRiMtfucQ6ml+AxEL7e09xC0/53Q/DmNqLTqRbS4PYJoypNIsPkZcQ2tg9V3tHb2Ia6zYumWo6mQ0Cq8I/t7po1BiKs+mvLlT1Ir1tbIs+da4hw/zMbpNrQG1kF7/86F3y6B5mdamP5wYnbUIcjysqH17T4k7B1LqXfCCohWPIb2xo0p9RLogvbR4TYXxhLn8uqIIV+j8IzrI7pzbPH5k2s2Q0LjTYhp39rmRFCYLmNj8wGitXuhsIM7KC2VNNXaSePOOpIIonbuSSQgrooUA/dgLv6NPZAi+jzEq6TKnZnExHChvNMiiFYEV9TrsdCZ5Hc7IwF9DHGvuLhwTaVso70K82JBREs+IGZ5PRithwURbepr7+g8pNA/DaP9STt72nt50eZGuVrTbWxe/R+l4SY7AhvY/0ORsmp4md+vhpQ/5ybnptlzjk/m8bvEtXuK3fOp5DevUloKbQFE47fG3GXt/POU8ViYm46ad6A1HTQcwLt+8vkpRKgvQxtKqAvSg8gI7IOYtg0RofwYEayQDCJs7Osird3G1t5ViMCl7p1BUxQyY22MaXQL/dwMuUBchVxkpiMrx8ywKAsE4udEC11HRNS3RgzTrZQW/R6KNutPSTSChXvXsXhWOfZty5xbA1nRrkYW158yU1F/7cGlkaCyI2KmBif9v93eSX8719vGJs1yuRjaLNdFzHQophxcMFZGG/obiIAHC9xaxCxwS9o195Bkt7TvghVnE/v9bYjJv46YsauNvY8LbEx3t/MHIEamczLmoZbXDYjY703ppt2GaB3aKDm/KBLwQ9KW1dGm+z6yahTdLoJ7carF72N9fJvofloUlE9FbqJhXUwjBomnGbWeItYAPJDERbXKObR88v9iSMipk1HNvj+YmIq6C2Ks/oiYpt7W5/YkcXnIbegQe58vIIYruBvPV+E+QYnQDm1MQWAcR12vgCmIabwGzbndicqLcoHpx6LN9G60MQerWz9iQpyH0DoYjejPWCQYLEsUFq6xORasC6vZHAgM/smISdgXMaHBZflDSq2s6Xvf09r4BDE+KyFadHjyvEdQaikq94yr2+++oW6q9o2JRe17IM1vqAU41s6PQRbINCZ4mL2/EIM7GglSS9p4fYQYhgftOfsBt9u14X0vi9brV8Ran0HwqC/VeLDmzWfvIk3ItCVini5Mzt2CaMhl9vf45NmXobx17jq0lx0O/IWCdbmBNbQxmud9gLeS+fAlpTQyJE8KaeL3QevlLko9Qnawc52QxTXENY5L5kJHIm0fgKweV9jfIYjeHowEyomIAfwA0c57KWUY90VC0+rEjKKHk5R1sHOT0PzrhfaIexBju3qFcRmEhM8ZiE7dS1Q+PEIs+HwIoucfoL3mJ8+GMrQ0def8GglxbW3+HIzoQaC5ryAaFd73Xog+PImUMdfZuY8p9cA5Au3ZJ9vnLUiEFDsXYv9WRsLhFKQAGZz0cXG0F25h72E6MSY6XfcjiNlA+yB6sXI6BoghD8/VBtH6J2zM9ij0bQu0Vq9DQsq5aK8JtKkfooP3IF5hRPJdmgV8KbSnp14de9q7mr/4vqtYJwugfe8LoivnzjYXLimMSRcbs7FEb4WViB4aRyCeZT807y9HQmk5hWVJttHkfOpyuiuiXV8h3ulQtP/+DPFMDxd+Ox4JgivU87yHIFp+PxYLjoTZYEFb3ebZR9RVGve3+fJHCvyqfX8PUmocZe94KRujm9Da/MDe3fJofSxuv5mO1sAZ9jm87xUQ3Z+AlIYhC/KRWAzw3HzUvAOt7aCeAN5kUo2kNCNgCD7fyM4F4rYVUQO9sS3oH9GmmhKFS4hakfbEoueTiFriFW1iL0LUFAd3hfB5YcT0TDFCcjPS1N6ItCmhX0ujzXgIpbE0E7CMk7awtkLa4ucpTYmbZrer2uJZxdgHt6aLEaPZzRb5togwpRrtSrUHuyNiuizRTTPUN+xn1w8r3DdNDNITba5Bi7u2zYXvSCwf9l3RvW8TxISPRUSxq43x+OQ9DiImA+lvzzzK3u0ZSNDsRnSXGISE7wvQhvKk9W80srr8ilLXjh3smqvR3E1j3fa3MdoWKRHWJjJ2PWwcl0UuXL9ADFbIrBk2lZ+h+fsmYqZCP9ehNCV4JyRQXYzm4L3EQrzB8uLQpn0I2rin2Plu1n6d2kr1zJ3g1vkmMY33TMQQrZPMnQ7Jb46w/n2MGNNbEGP6DJFRmURM9/w0kTl92ubEBZQK2JsV+rUQEhyuIm6Qy1u/gmY/pQWBOfkt0ZITkjssT4xR3Q/Nn+6IMeqXtLEB2jyXpjTL732IETvbxmpzxLwsjBRYz9g7f5joQtnbrg2uPCNsfpyMmMAwL1ZEDFkoZt/B+n02sR7eRUQX9raIGbqPpLSHfbc9YhZTC8YuiDH8yX0KCWbXIQEiuIv2JxZy72pjH5IZbJK+q6SdX1Iq0OyF5lDqSt4BKe/+Smk9xE2RwJ3Wh6wv1fhjxLqHv7Cx/TmRNl+VjNHmWLIGtD4HovVbQr/s+9Q69wxSMFxm86CsQqIBOrwO2vPa2f/XlrluicI73Y8k06Cdm0isv7g/mtfnIdexrsjq8qw99+TkPQ6xtl8lrpM17F0/an0Lc2EE0drmiAq/4Pq4K7EUTaADmyA6+QXaO5y9izHEOT0YKe7OJyqstkIC/dVI+PsSeDl53gVtrqRWp4rp4NG67m73WBopotYpXHMu2p+K4ScTrH8z7f2fhdHr5LcdSeKXEGO+OXG+DUNM9RQizdvcnm8zu9dyaN4FN8Al0Z413cYivJ9l7H3da79/FtG5jyh1rf+lve+g3O5iY3AO0VNlmD3bIKIraZhHaUKgYHFcAe31F6M1vzTmxp1cG2hnULx1Q4rbjpXeT4V3FvitzRCPdRrao59Da2UzG7M0qVqIF38U413snc9ANPAhtD5SC2y12UbTeRHiB49A+9njaG8NFuoFkDJiDFHxvTVJYp56nrsTCU+HBNk/kbjWI971H8QQoTA3OqD94n60bkYmvwmKvf8jlgdZEq21M+zZr0D70iGI/xuMeKAH0F6fJrv5BdFqvzvim95CayiMWR0jw9xy1LwDrfWgTACvne+INpTplNYqOo5Sl8eg4VsPEb/9EdHdh9Isa3vbpCwyi4sRrR6BsF1hC7oTUauYusMdSQza7Y4I0C8wImfnHRLiggVpKmJIFkcMeBd7xjeT+4bkAvembdl3T9GAxbOKsQ5Ea6IRhW3QBvwEMf4lTUZSb+1B+3wnEmDa2PNNtP6NKnP/DvZ+QmKQR9P3gYjODCT8TSIyANdTV+O2EqUFTB1RUGiDhIANkYvCTXbfTjb2F6DNY3fEzD6OhKx+iJHfFMuOiYTsr9Gm2odSl6T57LoDkLbvOmvDIa3fxfac9xHdv36q74jcDYciTfs0SuM8Hkab2mTEAL9F+eygNyOCfAbaiP5iYzecaDlbEm3o9yMlQRAwbwDObuR63Q9tZMESNRYJ0r8nus+mAut+SIESEqH0QgqXd1GShWA128vew32ICQkM4VAb03vQZrW3tXkX0Ro01Nq9nBgPtRyaX3UUIpRa4LdBdOeXxHX4OGZxRgLEVESL0g1vV8TctEfz6k2kdLqa6LraDwlMNyAGaW17F8OQMFfMOLqBjct4ymif7Zrn7d4v2jEZs7ImYzbS3kdwxQ71u3ol1+yC6OERNmb3J+2U1KCy/9dGguXNaL7W8TBAwnKJBSP5bgSiYY9QSMWePPvexCyaWyBPhqeJwk763upLNT4eWWUXtf9XQxadSxAtuAZTJlpbg0lKINi5Y+z69J6VrHO/pSAENGI9tbV3+ABSiqT0sA11LVdLIoVjqhAMpXlOSc7tgISYYPELVo2hiDZNs3e1JKJD79kzX0/cJ7YkFm9fD3NXRMJziNdc1Mb9abR3heLt6bj1JQqZayBrR2oJ+sz6dj2iX8E7YVlEa6YRBccriULoQBLFQCPGPGT3fNyeb3liDNxKlA8/WRDtF2dTf6mAILyniYu6o/0m1FCbYd93RcJBV6SA+RApMxcotLc2dRU2zvrUHSn5Rtn7vtC+3xsJHWuhvWkqEv62LbSxNVIqvojo5d32/KmC8yokJH9sY9AOCfPn2/33R5aeUXb9UvaezrG/Mym4p9e3HuzvWsj6dCuay/uheMU9iXTKIf7tNUTvgvfPAHv+c5Ah4V5KFfjPkijxk3VYMdsoDYclnZPcI/BQoXzOOdbe28nv6g3JSebOxohunkBp3cG2yTU90bwKhdiDYnl/4M5krNqiffRhxJscSSyZtBmRx1sP8d23IxrQKZ0zyX5wLXXDUZYtXju3HjXvQGs/qBvAux1ilh6wCb0P2pxewLQXNtknow1ha2KChnIMSdAUv0pBw5dcM9kITCdbpM8hgvc8Ubjsg4SAoqb1ZrRxhYV4ADFQ9mPEfHxiRKC/nT+Q6E+dZjC7mtJMcztShcWzgfHdAvgzYsbGEd1XuxMzf51XXKhoQyrWHgy+7msiZjndwPsiRnLLevrSHQm/fZPxSjO99bbx/AgJ4C/Y+c5IMx0snRfZOCyXjgOlVqYlEIP7ItpsgyD5M8RsbI4Y8iBoLl6mv4fZd4/aO+6OCGYar9gFMbu/QhtDV7uuH1GruhPmYllofyGiK7JDDPJMJCS/gjb3UxFznmadnB8R+bBRDkIb0hdos1vdzr1HdMU5zr6/HTFZVceDImFjut3jAXvmoGFMYxqDwHoxEuxC6Y2iW+JOaG09Yf1cpDCXlqZUcz2UqOEehtb0DvY8ac3JF9CGdFI9z+IK/XkDre2NMQHAzo1AwvwblK7JnwqmWx+m2TifiuZpECD7ozk7Ca3rMWjep/M9TSJQ0V0WCajBQ+B1G+OHEDOxATFepRtiPJ9DQuRtxbFAjNKyiNE/FykNfkS0IdCilUliKYnKjF8RLZIj0Rx8CdHs+ZHC4SqiNjmMxbpozV6IBLXUDXAn6+8kEgsbWnufIGYluHHWm2ocJXW6DSlqQgKCrphbOBJ2Qjx3+PuAtRn6fAdJPb/CmmvQOteYA63vNdCa/ckVMR33QN/s/oMLvw+leT5ETHsx2c6WaO4FYT7U7ZpEDEU4AM3Lm9BcD+PWA63V8NtOaH3fhehqF2I85DCiK+H2SAF4PFLAzI/WxRlo30sFotRzYSWbB/9CQsVKaJ0H69NkJBidgvb9I6sc48CQp+7//W0OzUT0PHhT1Bd+8jqFGOUKtCVd35OJ8au90F78uo3hiGQcHrd5d1cy/t2sb2G89iUK4kcl9whz4zFr/1Yk0I9H63sF5AZ+MRWEViSkHGPvd1M7tx9SCHW0d/wKmvttKI2XXsiue8Xu1RnRxQNoRDbbwjjvjYTji23ehPdzAeKp0iRAm6P9/AVEB9ZGvMm1Nq67EunHfPbOu9KIbKPVzAu79wXW/k7ISjbS7h+SVlUtDNl82A55ibxi82QxtAeGLJu3oX3lXGIZioWSZwpzJ9RqXNzezQVIEXGUtXE5UuiEcRqFlHTXU3DHRmv7ZeTdthqF2pSt4ah5B+aFo7AAQ/rgCciUfT1iDs9OrlnDCNH6RnAuQxvf3xGxLBe7sicxWLx/4Z5boQ0vZIhaHTEQixXa2Bgxq6/aol7eFnnQcna2xdQbbVyH2PmLiMkcuiAr2fckmc3K9Lcqi2eV4zscCUlfUpp2uy1ieIPrTigjcC1lag8m/boHMboHUSbVdSP7dogRkkOJQtwQJCwskVwT3FluQNqv/wKTk3b6IK13kcm9EGn7AwGcj9K6WAvaM/+DUgtFN8wCh5jgG+29pVkpHZHIrmhj/BqFmoY2fgfb/4ERXhVtrEsk13VBjNIWxPpYSyIBOGUGd0HzeDeiMOvs80ZIK/0hsp6lgnB7CnXaqnxHz1rfTgtjjpjeokWnKLCehgSKOjUe7TeHIqE7jaHcAzGw7yImJHVT6UYUjv5o72NhSl2oq9qEiG5fgfkdgATQIZhQjxQENxAF3CFoM9wQ0aj77N0eaWO7NNoI96a0xtMOSMN8IzHT4CKIVryP4i3G2Px5h7ruZ+taX3YlJpFYE23YQbt8nPUprOUNiNazMPc72xxZCHg1af9mYkyrQ8z2fdbflMG6ByncumE1NK29NxBDuACl8/lsxGAsjBjT3ZHiYBISKtKC4i8jq8ElRIvOApQKn5VSjXdN2joMaeZvtP7ViSdCNOxRe3e9ER17197tTfXMmYrWuSbSwHbJHHuUxLJc5e97IKVDKM3T1t7jPmj9XVe4vj9iyv+NZeG18xvaHHwKKRpKsmHa392sj1dQsMRaux9bO98hQeQo5Ja4cPKOFkBz9SnrR+rpsLU9T3ukUBlPdCdeHvEFBzdyfBZEzPI9lO4zG1K31ElV9ePquVcqXO5DEj9q58Yj3mCSvaOByXc7InpzH9pf90+e+020fkJm8tuJ1po2SDnbz95BF+R6GPamG4leHhWVfZTGkk+lkESLpOxQmd+ugpRCV1GlB1Ly2zAvhpNY3tGeHkI1glC2P1IKT6dUaXYa4u9CW9uhPfJfvTzMAAAgAElEQVQapIhYHyml703aqjrbaEPzAgme2yEPmEmI5+tR7jmrGI9OlFr+JyMr3ESMD0aW9hBXfm+4Hu0lOxbau4yYcKYtMrSMQcrq3kgZcyOi1cGg0AXN062J63tTJCAejvbeh4j1WOe60gwVx7/WHZiXDkSQByAi95AdiyJGMmjs9kDarPdtUY9AjNbyiFkOC3o5I0DX2d+1bOFOI2rNHWJeuyKG7QgKZusyfWyLNCFfIfeeVOu2uRGZpZH/e4ihuoeoQTvb+joWMUu3UHBhtOsatHhWMZ5BS7swEnb2RpvyLRhjVbi+Yu1BIjE9ADGxY9CmPRERz6qDtRMisg0S6PdC7j3TbFyWKBIRSt0eVknuP87O97B58AoiwFuR1NOxa/oiRvl9xFymRehXTO6xGdpkb0HMSfDXX4ZSt9J1kWCyezLW2yCXkyDkLYc0fl9iWdPs/J3InbHERSbp5x1IuH2a0rINOyLt4oM2P0bbfEpdVpZCm+XtSOMe3uFwytRKauBddUUa5n0oja15mNJsuVUJrGXaL8YxpLFTTyAFy0xK4wZDrbprkFA/0u5/LGXci+u5d6ApIxBdOQlpmEM2uxkkiVHsb7nEDcEivSZya/qDzZuiMusgoiA2xO67BmJkxxDdZVekvOJqHcTw7IkYw32RhnZRxNScbWOQutiFednBnqkjsXzCgTZ/7kzGNvztbc96D6JBMzBlk/X1tkLfght7oL9rINr7GpqrY5FwsxR1Xe3vRvRuHRu/txH9XJAqU40nbV2BBMH9kEXoYutLp8I9V7Px2jA5txT1uPAlc28NytRPm9UD0bNHEeMe4uQazUQhZi7EtQ61dk9BjOo3FIQlJMA/QJIJ1c4fhOhPmPOnYZ4pyZo9CQkmayXnr7f5tIa1OwJ5mdxh4xbm1kX2zqfY/ycgJUV7Sq2bQ4jxdodQEIYbGiOiVXo8Ymh3Qgz5pdbPOsnSkt+WDT9p4H7d0B7r0H67GFKYXYfFfiLlwgpoTWyI9uNPiDkHuiIan9LW04Ezw/q0vk2lNCZ2IFqji9s1k4DfITr5SpXzp5gw5kZKFc7PkLiJlvs9Ukz9hzIhCQ3cO5RJ+BXiA4PCdX0k1JxEjInsYO/z1/Z8wZulxC0a0dwQe/cWogVpbc0naWS20XLzwt7jHYX73orWXlXrmLqWxzTJ4Db2rK8Q1+T81v4TROGvLVqTRU+KR5Hiu5gxNiSYc4gWHIMs/scRM6Sm+8H9RMV7yOfwJEktyNZw1LwD88qBNvVK6YPTmJpyAfXTqasdDwLMlogxuoNooQmM0L5IEzodMZa3Io1z0P7XFyDewyb+W4gAt08IwsHEjEqvJItyFeDWpI3eaEP6AxbvlXzXoMWzgfFcAAmhyyFGMTD+HdGG8HuS4tbUX3uwHbFW0n2F31xs72DnWXjnM5DAeCBi9vZETML5RM33kYiBOJekJpB9NwRp/0cX+j4KCeT3EusLOSQgTEGWsjPtvR1I3GACgbuZmO31WOSaexJlNn4ktN2FNGBhjNsQraiP2twIdY0eQMzms0kbwUXmdaI70zaI2bqocL/JRCF2DyT4XEqimUeCSG8kPJyPNu8TEOO3XmPekbW3tc2hMBe2Qa5YjRJYq7hPudipoEFONZ9jERPZBTGDIUHMl8CSVd4rvPPO9myTrM+/tH4/RJnaa1RI3JB8P9ze+dWIkQiZ+w4nWhhCIqkP0Aa6JdFlJ63H1RMxQLsjBtKhuXuzzbfuiHY8h4Tyu5HF+kVinOWuyAo0jZhxM7RzOeYinzzbTnZ9qPHYHzEDhyTzK6z7pZO+Ho15M9jnt5BmODBF99i8SEsFOHu/r1JqZRiLvDYm0nCq8XeIwvsOwGXJ9Qsj+vkOMUnDymjN9yTO0d0buyaa+7B583kYtwKNG1BlG+H99LExHWdzIcSTfkMS05j8bhWkKLstee9BeF8MrY9giU/fU2/qxj52Q4zjcDt3OqWuw0sX3uk2iBZfSUys1BPt8aHcxEaIVt9KhRCNMs+0LKKptyELbnAR7I4Y/Vuw+PwG2ikJP2ng2qXsfS1j62EJYqmMzxD9PwrRyLeT3x1k72YmsY5bmv03hHWkWVuvIPFqQbToHBKlNVaXlkI28waeYTHMdZaY6OdM5PlTZ+5UaKMjhRqYVcxZZ/P2KKTImYj23DuIJRYeRbQozIulkcLqD5QqVItutqFkSwgPanK2UaQ0Chl1T0f85m5E6+pw6vEaKNNeEObORXvZbyl1f37MjveI+8hqSPl6OuJTbqAggNl8vAHxjtsjXiMVMHdF+3ioE7keou13Upo5+peUZhKdiJTuY4gCYr0Ks7nlqHkH5qWDmD74WkrTB4fEDeWYwlXRZpkyheUEmEONmPzkv23fjUVEd3XEZD+E1Wyrss8DkXCUFjl9yhbNIKSFDwHyD1BI52vnV6Y0iLs+i2e1mqPOtpB/h6xWXSitmzWAgtWHBmoPIoH2QaSVTd0GN6KM5bCevjnr3y6ISXg0uceNxNIQhyKiNoy48YxK2hkF/BMlPNnWzqX9akvcVFZBhD+4v61AFJr2T67bnSRuEzEg2yFhcdPkun7JNd2R8P5/yIIYrDlXE12GN0Hz+TOkRQ2bezoXA/N1PYnLYvL9VsAPlNbrWRgxVSFhzNaIwU43s4FIMN6u2GaV76ud/f5CxABeT3QDqVpgrfJeZWOniEzoYZS6AHWzubQuVZYxsfn3JNrITiQKQ92tnUmUxirWWXOUJm4oWsk6ovU1mWiN/Iq4saeKq6cRY/WAtdeGyDjcjhjd59G62IWonQ2CzjC0RnZGjMwldn2wSHdFVsFvSbwS7Lsh9hyh31cQ63r9FTi9zHNvihQxbyAhc2dEQ9NkBf1J3OHsne5lz3ADdWPTLkeWuUAnF0HeGUHDXynV+OPEJBLdkcB0Wpk+py50RyBFxRmImXwGCZjHU4OMc8mcGITW/0jkiXAfshx/SiPrXiGmbRfkEpzWOFszmRflShwEK81uyfnhWM0zSq0Mp1NqBTqNqLg43t7dSKT0TDNtTkKK1sOSc4vZ+w/uio8hJnWqva8+aN8eld6zgTHogPbjnZBi5nFK44SXoUrBpFqakvy/Flq3Z9sYLEHc8zqiNboPhT0TCX0/IqVxYLADgz8J7Q1nIub9Y+oWUQ+1+06iHoV1A8+xorURLIsbWXubk+x5zbwG+iI+Iyif1kTKymeQ0iZ42qxNLL+UCrdbU8btlMJ6phmzjSIB7wx7z2NsnUxFPNepiK6HeogNWaTD+1se7QUdkLLmY8RT/Dy5ZgJS7E0gZlE/xubHKEqt5e2JNHUbxGf9EvHRbe3dPoto+G8pVeKlCX3aW/vF0JkbkVA+oaHxmpuOmndgXjioP31w58K11aa7bkiAOQoxw+si5vwwW2ztaGScGqVWyt2Rxui3iGnrmSzCHZCm5gXKpAUv01ZFi2cj+nYBYuTuRJt6WyMApxIZ6VB78ErK1B4kBunvZeN+i417Y8epnMtaOxv/26z9F+18G7tP6rq1JRIuQnzJfEboQga5Y4gxcxNJrD6IUf2epCAr2oDXTNpzNuZ/xQpbJ9f2S/7van0+hWTjRhvy1fb/gojIbmv3vhUxQxNINLblxghtKHVcZGx+jrE5dDflLY+vISXCfMi69GGxnSas0y5IyKwTN0cDAmsj71M2dsqePygwFre5/TfEXDWKyUHr7ELr88zCd7eSxH028K7SbGrHWJ/OJ7prbYDctUJG1eGUV1z9ipjC/QakiErLQYxCFuUb7f0OtvnWFTGWzybjVCyavK/Nvel2XUgicRfR4tnLvg+0aiBiuv6ZXL+H9TMkffi7zfGdMUs/0bXtMbSm+9n5NZEAPA4JCC4Zt40QI3eaff88UsQ0lGp8cHLP+RED9yckvKYCyU9Jo+y6C1ECmhGIkXyCMslbWvooPP9FRGuUQ/vh7dXMw2KbNnfGIMVGsDSfBVxfxe9LrDQ2XsHzIfTvGJujGyEafQFwc/Kb/jY3b0JM8MGUKlF2QzG5TxG9FsJetKXNkwXtunMRw7kfMX613rVOdPdbC62NlYg1AE+hHrfOJrzL0LdtkFB2oM3DK5FiaEsby3bIQnOOjdvGxORqSyFBZCmk+BiEFF47IYFkJbSmTiUKSG2pW7vvPBIBdxaepQdSkNcp9t1C66AbEoLvRdb8kCNhW6RQnIH4jWDh25noTbExcR2tipRSuxbaDwqy5sw22hnxVf8gCugb2nNcyyx4D9hc3xMJ2CH75g1IETAwuUfg0/5IEpNbWEeDEI9wBTHJS0ioFMqrPIKE/EOJfMvalHFxRfvNdKT8Xcnm8UtIsXQPlqSwNRw170BrP6gyfXDhN3WYwmRhNyTAOCOOk+z3JyBC+1ckGC0xi89RtFJOwKyUdr9OaEPtgTbll+1+i9XT1nWUsXhWM6bJ/0va3+GIUbsSCU6j7Hxv6qk9WGi3s43fgYihmEDiP15Fv9okz3eMEYz5EQM/2YjH5kRm+ijEOKTpgJ8gpgHvZ8/U2QjRK8gSeQoSjIKFeISN+9r2bC9RWqPsLhuHwNQsjBj3d5FAUaw9Nh/Svp2FrBTBXex+SjVk26MNazpiYnogS1nfKsaqoouMtXWKzYlriIkb+tvzb02sx7g9YhS6N3TPZlrLZQXWWWirTuyUzZOZiKm5Hq3nxRBzXJUFoMx9htp8eBUJVsvZPQIz2hCDGeZ0P0SL9kUKpGuQ4mG1Mr+pqLhCgs4hyBrwdmGe9kCCUU8kRF2F1vJY5IL8LjFRTNj8hxOTOHRArm3voTUfMgs6JBQ+gyxEaXmS3YnuOwcShYg+Nv6fUBp/lBbEPhOtt5uRMmI1e7YpyHPhGETrt0ZMxQmIAdmPBlKNF8Y+LTezNGJ0foq7TK4/DQlDDgkiFyVt1CwRgY1RcIfc2vq5tL2vRlsfiQrOp5AVpZe98zCnq/UWCfRzB5urFyFa8hxRmD8JrffHKHX1XC4Z2yCgnEppHNo5KPlWSE7UweZgGuO7gs2ZM6vscxebR8dZP4MVpzdSwFyG9t321bRX5T17Jff+NRJGJiIafTZSIp1emLMr2Xu+Ee27W9jYpomLgmvoJTZWdbKHUmXtvmqfA7P2ICH1LWYhA2eV9ypamtuh/etYxPuchyxMgxDNOgPxaWGdzIeE6SfR/r+cjcNY5AJe1uuDZsw2inizY9D+/hTRU+MGordGYzJ29kReaecTY8YPJZZ66ocMAsEivi4yLnyCua8nbT2IFIgnY26mxDUbeOVjEH/wIjEh3E3AsWX6FhJ8TbBnfdr6thymvGwtR807MK8dlEkfXOG6NN11Gp9TlQBj1/cgptu9AlkRKlphKvRjGJWtlEGIOBER5LuTBdzH7rlJlW1Vm5UwMHsDETN8MxKUtiVa+dYjMmcVaw8mbY1GGt17kYC0PBKMbqeBxDdJv1I3pg+tvaeQW+QqiBEuVzbiEqIFYALwVPL91UQt2yAkHL9v45YWWP+chCgixvy3wA32eX6711eIiUk1hw8il4i0ftweNpbLIevk1WgTubz4LhDzGzTPVwHnp+PRxLUyEEs0kpzbDVk9j7fPKzKbiTKNiOmYhbYH27wLLsBbY8Xom9BmSM70JXKD3Kux7wgpKELiiF5oQz4BMQTlFDv11WnrYHNvEtJ8n0BdV7CwfvvafNzX1tWhyXdtEEMwpPDb9sgKsjsWO4RcPS9FSqudSZh2+82GyDLxU4ZQO78OVhMufTb725XItK9s4/IOsmLchdbn9cBDhd83lGp8DKWxZecg16qpRAF1A7SH9LXPfZCnwzS0Vs9A9P5mCmU8ZvNaWQcJOksjxefDiOEd38R210eCx4tY0qhq5nTy7nay8X4VWVNWRLRlU3uXQXnaGytThFnd7fczSCxFiD7fgYTD8UQGdDHiWu6B9uq/U1dg71lN/+2aATbvv6bgGmvj0r8Z319wFb8S7TuhZtwgm7uno30puGm2Q5atMC9XQ0z+pYhWhLnfkeiVNADRgCvsb6gvnMbDVazdV+VzbIeErauwOrpo3/uUKuOkZ3H8xhGFGGfPEATzEDu9IbLYnmTz4xSiK3lwKb4HeQDsgnlI2JwdSpm1TROyjZZpqx3iA95De++E9P3UN3eS/9Ps3MMQf3Qa2pPC3F+TJGGMndsGuS6vn5xbArjG/n+ZmADnAnvPQaG2GYqHfNK+34IkWUyFPndGa34pJHjPwAq1t5aj5h2YVw+q1MRRf3xOpeLpbSijQSXRIjfi3vVaKRGTGgokf4kl0iBhnKptq5F9ewgJvssiwfgxYL/CNfXWHkzG8V1kMRiAmMunmUX3EcTI7mj/D7T3cw8SdoMGagukFQ6WwL3R5nASURPZk1L3yZCp8gz7LrhqViqwPj/Stv6U8QsxvvcjZnDH5NqgBWuDBNXRyXcdEHO7EBUCwK0voXZScD9tFiaTuPGvgBiolBnuiCxBLaKtnZ2HraPVsE3ezvVCAtOQZrrHgohRC/OwoU07WJj6oljLjym1RC1BPXGGlLdmzmdzOC2UPREJK0GorEjDCu3vC9we5kIyh1ew+2xv546w8XXIgj0NrdNgde+NlCl3ILpyGGJAuhTu11B/1kNMx8oYzUEuRoEmTsTcYu1zfanGg0JtP7T2N0HxywsjobYjFax4iBncEzFVdWKsazC3T7XxnWx0ZF2Skh9NaLcTEjDSumoN0h2bG+/bWL5FVKwF2hXGtQulyR6WR3vXB/ZOwnV9sDhjJNzegawh+yJm/lRKMwuub9c/R8F9rRHPfjBSNjyL9tHFbY5fNivtNXCv4Cr+KRb/mHy3CbKmhLE4Eyk6brF5PCS5Ngjcq1q/r7I5ETxbhiDL4USb31XV7qun30Ulax+bf6Ns7Z1OCygMk7EYbPPlQ7T/B3o6leid0BkJNUEAXtvG+vYwN+x5T0GWwqeAVe38+cAp9T0/s5httJ721kier6H9I7zv/ZBnyGtEN/ldEa0LuQqCa/r9wCVJG0cDB5Vp+xob23Pt84rI+tsVWUNDu2vaeP8G8dA7NOJ522Ku/63pqHkH8lHFS6o/PucWKsRFUIEpaEI/yhU5PQBpnzYi+mkviTa9ihqmcm01oh99qCvIbYo2kRKLGg3XHhxBLHERiNTRWFBvQ4St0IfliSmsFyw86wH2/3ZoE5iAyjhcQ4XYQcq7T35MafxIpQLrU5PnWRBzg7LPW6CA7hcozaa4BcYkIu1e2KSWq2Yskuuba76lFsl3kJviBTYuSyKLymyPVWquI3k/29mcfBIJHQfYXFqIxFLezPduyCKyDEkKfMSEXYkshVVl2K3wLrdCRedfJxZqDuUe1irzO1f4fcrgrw5cWbh+R2IR+jY298cj173jkYDXHQlEgTE4HNjb/t8EWSV+iRjroI3fCGmdOxTuV1YQRIzHLzEmnJjOPpRiqJRqvDOib8Gleaq9iyOJGvbNKM181yZ53ppY9Cq8s23sWRZBmvPQz8eZRWGnmfq3D3JdX45YjqQLEtbSZA/TkFD4PBIUgkfDkoV5mCa0GowsmS8hq8JByKXtZLR/p9bBPRBdqzpJWJln6Wlz+XO0rzRLbcUK9xpqY/ECCfNMqWLuTaIwfQnavy6kNM3+5bYWhyLL/TQkLPZH+/fLaF+rWLvP2nmGepKvEPejrZHgcRDNtDfVc89UEXAXUtCsbM/0ABKE08ymRyHBt1faN8RTrZZ83hdZiB+3z8vbGPeuok8t5plSxb07I3q/LjGhykMkNQiTa+dDPM50+81UpJzpT2l+hj1sbn1tY3oE8lg61ObgJ8XnZRbDI1rjUfMO5KMRL6tyfM6y9n3ZQN8W6EdghFZHGqgbkcUumNkvpEqNI42weBY+30aSPRFZ/F6hTFwgdWsPpjE6C9jvRifnDgGmNbZfRuCCZn4S5V1up1BaXuJ6VBPnrDLt1es+SfUF1m9B1stpSMMZrInjERMcNu0lkKYtLSa8PtqwasZMIref7RHzeJxtBicjt5i5vmgqUhT0RRaBx5AVYAayEtTKLa8XYiw2QJa5kLF1eeRO/QOyTFVjWQmM0Apow98RaXrvRprrMFeXQELXjpRP4tPOxmg+W7dtEf17AtGiYYg+hriYzjZHzkXC1aG2/tKkGcEbYHpyH2fXHJGce4+YvGZpCgJq8owHWR9PRNrlPZDAeCtWB9CuqzfVeHLdHram303O3Y+yX15Lab2rkiyrNZzPzt7VdKTd35doRRtGC1ijGtm/JYx+PE+Mx9sJKSDDexyGKVjtHUxHQvy2lGZQLia0ug0JNKcgunsyovMd0L7yic2FAfb7QNub9M4Qs7xGU9qo8j5tbTyesWPRZMyORDRrI7TO2yAF6J2UxtJdTbRsLWJrdBLmqUMsxdBQ7b5qBJ7VUOzwSLT/v8tsUDjYMwaX40FIyfsi4s/6JWN5BaITx1Ca6Tp4Y6RZqkPm6vdsDh3d0s/RhOcPtKg7SSZbO3cmSt4SyszsgwTkKxGd7oD4uUFoX0xr6YXwpsNtPT5oY7i+XXMasbZxoDm9EO8827MXz4lHzTuQj0a+sLrxOaPsfEiHW2+gbzPcPwSSH4PcU1ZFCRAeQJvdRCOy3Zr5vqlVZE/bYN6ze52INt6j02vLtFGsPTgWxdJMsjF7DDGGH2GxM43o335E97T+RGvbpUSf/s3sHsW4oVWwOKsKbafukx2TtioWWLffOKJQ3ha5OhxKab2xw5BLRBDkL7WxPMAI7mzXylMq+K6NtOFpWvp1kLZ4t9nZrxZ61sHIetkLeMfOrWDzulEW8Bbq31DEaNxHokxiFiwKRhtCTFQ75JJ2PxIMxiFBdyJSwoSi8WkZlvmQG88iSFkyzM4fb7+ZQmlG41uIiXHetHUwCll5BiXXbYwY2BcodXsOzOzhxGQBOyMr5Q1YPHJyfXtkLQplU0bb812CBMGGUo1viATe74jCSFck3F1j/TgLCSuLIwHjQ5LkGHPagVxon7ZjM7R/VJWwq4X7NQ5ZE3ZEtPpVYixZW5RY5xfJ9Z2R+/0M6mbcLueR8anN5auRQjRV9E1GdWTPqvU4NGH8FkRJSdIU+v2QMuZYTImKhN5Dk9/tgxj+6wrt9Uc8TNW1++rpW2/gRPt/Jgrd2NPW0S7EzKrzzcqzVzk25UIzJiDLbBpXuq3Nm79YXzcrtHMvor9jkbWsO3KxbFIG6RaeG4Furozc2z9EQnxKc4P7envER+5hazG4+o+ioBChND9DDxuPSyi1zm+JlAx9iILzGZQpdTOvHjXvQD5m8cXVjc9pVKBvE+8dAsn/QEzEsh1KGXwBZWrKNPF+qabnc8QAnYm0OjfZ5zpZBCu01R1ZKK40YnQF2szPQRv3ccxCPB/a+N9DG1WweK5Hab2mnyGm7U4kKA8uEu/63hWlWfwaLLCOhL4TSYrv2ry5H3NVsz52sX6thTalrZCm9l7K1DKbDXO7f/L/ELSBvkVijbXv5mrNnY1/yCC4PFKctLV1e3cN+1XO4rQ5soRcR2mMXmPcnzdCjE3KyJ2AXJweItZL+4BYZmRzxHAvQnQp742YqCuNDixOIc4EWcgnEBmswYjp+5LEbTWdS0QLxrO2VtOSAxfYd+ciK9BxWHbQpI2tkMLo4EK7HZJ+VJNqfBdUxuFepHjphJi+CciVaa/QJqUudzWNP0nGfinEaLdLvrsIMfs71aBfafKvPVHc2MKIBoZY+ZBsxdmYT0RWoXFY8W/7vo6bGBU8MhBdfQgpFI+n1F1vJSzp2dx+EEsehZCJYUhxMQUJ1qFm61Ck4DwFCcXfhLWCLIZHWDtV1+6r0J+pSEHSGylb2tv6CGVlLqIQ/98CY1Ips3UoTbAdUuxNQNatGxDv8GdipuPxiO7sRMxWPZok2/ecfCDF7HEoZ8EEO/ZEAn5QSh+KxSUiReCySLF2I4lSjeryMyxu43x1WNOIJ/2QRuazaM1HINIZczGcc23RJL8RMWVHeu/fdM6dD/zNe39WC9zzYLTZ7Yo0mYcgK9Ou3vsjm/leznvvnXOHAX/33l/nnFsFCQTd0QZ+pvf+zw200x/FTV2GNplfeu8/cs4NQ+5hXZGr5QQ/CwvDOdcOMbBjkLvCmcA/rO/zAT967//jnFsbEW+QheJ27/23VbQfxmF3ZFXc3M73RMLbRsD93vtHkms3RZvFJFRr6lvn3PNIYPbIytLe+jo/0ng/671/1znXxnv/Y2PHoalwzu2FlAp/9N5/bud2Q0zaf1HM1szwjLO7f80F59xOxKQ+v0fzcj3kOnm29/6OGvSprff+B+fcckiZ0BYx69ci18nxSFBt1Bp3zg3y3r/tnLsIuSndgixmk5Fl82XEmH0LfO+9P805FwrJr4uEiKORYuUi7/1vnHNrIqFwCTR+FwN/tnm/C7IsPYLWxN+dcw5pk1/z3n9RoZ8LInfEzRHT8D/v/d+cc7sia+wVtoYfR4z9I4C3ew5Gc3RlxNDd671/q9D+g4gpHYiEid2dc/3seeb33n/vnAsM8HBEUy9HFswfnXOLIKHxM2Qtedza3d9+8xmi/5835v00J5xzRxHju17w3r/lnOuKmO1jvfd/qVG/3kF0eQBScE323l9q3wV6+dNfRE83QUz7B8jlv2Lf7Tf9EW0/2+bJfkgAGmDfvYUUOr9Lfzc30rGEVoxFiqqlgPe998c451ZHXhqve+9fdM6FZDcPoDj63dC6nY7cHndBVsLeaB7PRGsruL2/h5KuzAj3rdCn9kj52QO5do61vWwS8rL5MxI+Rnjv/9X8o/JTP9oiq663NX0VouubovXcF7jKaGIvYiK56cgz4Vt7hh1sz+6OBMlNgSe891e2VN+bA865LZEiZbR9Xhl5MqyGlN6hnM8jSElwkPd+ql3bGcU+f1xoc2OkHOuAPJJeQjTlKDT/jkV7xQCim+i3wPPe+3tb8HHnLtRa6sxH8xw0IdC3ifftibShv0Yalc1b6D59kGWxXBvmvNoAAB56SURBVPawxmRk2ghp1b7CXEDsfDekYVq7ynbSlPKrUuqGti3KtHeVfQ7Zyq5GTG7IJLgHVbirWBtpYpiKBdaJWu35kNa0C2JgT0NukrciorsFcqM4llIN7VS0Ke3X0nOnimeeYX0OGtpF0IZ+eS371cRnSoP1uyKrQxpjOogy9apq0M/HkZZ2S5Tx8nYSF7XiszTQ1hCba3sjwWll5AZ5tq3HYWgDv5PSzMD3E+vOtUUMwzRkcTsSMYntkdb8dKJlbiQSKB+060cjetiukWOwEBJ4xyXn2iGX6GJq8aPs+h623sYhS2SatbfeVONJWy9jZSIQfX0GuaQdZOfa27t5CtGTYD3ogCxX29dgvqQu2T2Q8DsZMbAnI+buiBr0K8yJoSSxhMii8BLRwhe8KLZEe+kY+9wJJRO5njJxphXuGdpagOh23x0JNhcg5eziTXmuOeWwd/0GUk7MSOboEpTSuovt+X+GmPBwfk1ircE2VFG7r5rxR1bav2Mll5B1/HHkpj7bYuEoZLYm8h9/BM4oXPuWzdOlkcLpNevzysk1y1CjpCyNfO6DEO0s0sn1qZsMazPkwfVyQ2uMuvkZ0qyuU4DByecOTXmG1nrUvAP5mMUXN4cF+jIbAskpjb0plz2sKlczpIHbD2lv76IJ8Y+I+XwNuZMEl7SuyA0sJFlJs5UdhhjRcagEQUl2wnru09gC65chd7xLienpV0MMeGfbYDdHQt6DyA1iUWJNnmlUWTuxhd/5IGS9uJlYs2iOjWdoxHMdZpv7Csj6fA9VFLWfTX1bEng0+bwAcsO5zOZHo9xqkYVjX5uvF9g6bpu0fTaKU1kFJYG618bkOrsmMO7jbWP/hfXlPqJw9FO6fSRshELdeyD370uBbWZhLJZDFoKviPUN+yIBr63db0tk1UrLiSyNhNzdC+1VTDVun0P2ujROZSlb/ycW2uqFrBZPIDrUq7HP10zzJXWp3dze9UL2bndHAvlFteib9Wt+xDw/bvQkuFSPpjS+OU368QfEhIeyH1UpwIj78mqIrl6N6FcXmysrzso8nFMP5NJ8lM3R55LzNxKT1bRBQsAYW9fr2vmzkDAd5k/Vtfuq6NeeSHB63tbHIKQ0LFt2aDaMUxqaEfiPTxGtG46EwVDmZS2bgyshy9YM5BJbk/XdiGdMM5f2Nhr4GBJwQ6mxQPeXQcLbnpigZvPoR0zh0sC90vwMD9n4PYGUxMch9+ybKVNDdl4/snvnXAxzRboWuemFuKf30YL60FfhMji3wdwmdkWJRkDWua/9LLgh2vgdTNSqHYBcMOtdFM65Ht77vzjn1kfMYG8k9LVFCQu2Rkk5jnbObYEI+IFe7j6LIEZ/W7vmmir7Oj/SYH6MtKATvNy9VkUa0S+RlvUH59x2iOE8GW3GyyKm8jRrq733/r/OuTHIHaId0op+jwTFJxEB/76avrU0zG1qF8Qg7Om9v63GXWoSnHMDEEP4XyTwtEFKgheQ+9tvatg9AJxzTyMmZIJ9XgZZrjbzVbhFJW5y7b33/7VzqyHXru2QleVsZAkbiizXJ6A4n/8iJvn33vt/228XB57x3i+VfD7O2rvJe3+Gnd8KMVIneu/Ps3MLo3X+ovf+4Vkcjy2RQNoRZRD8KvnuYVRb6n7nXGfv/XfOuS6oPtYPtiY3Q1a7tZDl9DVEs0egLJGXJO5yZyDXuF29939yzg1B8/5gu99uyIIwv/f+KudcSH2/ILJc1evm3lJwzt2MLFq/RnTlBiTs1ZzJcM79HCmz/oAULP9EYzYTvZeJyLI8CQkHGyHr5BS0r24V5mKV93sAKRp6o1pyOznnBgL/z5uL6Fzs1vmT27/toTchL5MDvffPWOjHtt77EclvAv0AMfr/QvvMDt77T4w2XIz2t2+RC//LNve3QnvUaY15B8m9D0VKtneREmZO2dd6IPp3DNq/HwD+H7KS7+W9/9w51xvxCz9Hit5dAz2dkxDmhLnx3oreYRe0rnogi/+r3vtt7PqnEJ34Hgl6X3jvL7Ax+cF7//cG7hf2l8FIsRJcd08nenj08uYympGg1lJnPhp/ELNEztWBvk0cg5+yhzVDWwOxbIFVXNsVEeA9sfozyXe7IjfKn2pv2f8/YjUMk2v7E7VeDdW/S91kqimwfjexCGobpDF8gtLMYJ0RMxMshysi4vkhigmq+TsuMw41qzfUAs+yBRLyrkMuL+ciK0OtNNFpHaTdEYP2GbI6HYKY4+OK87GBNvsiK9aYwvlHEDOwLhJ+eiCt/9s2Dv3LtNUNMUVpyvZlEVMeat855EI1Bnk73E2VLnmNGKcjqOuedCawb+HcPZiVjwZSjZMkoSFaOsahZC43IstgqCO4NZap2J6xT3LPqlzTW2j+zE9p4pw1kEvwZ9QgCy2lFoV97P/OSFHwAlI6HEx1ST/2r/Keg9D+0BlZo+dHMds/s+8vppCMam48krEdhfa8B5Hy82okSL9FGe8Zm+sTbT7fScy23Yb6a/fNh1z/Rjahz52owoJUo/EciLKahgR5X2NlbApj17/Wfa3iWa5CvNEa9iwPob1jY6L3xU7ADPu/OzFT60ZhPjTifiNRnPaopO25tnbvbHlHte5APhr5wsTo3I/SdT9CZNq7I+vOLdVuUq3laAyRaIZ7tUWM18fIlWAdkgKxxjzU5+ZQJ3NgQ/ezv9UWWB9g8+JrkpIGRlR3Tj4vhNxGDqY0y969zEL20nxU/T6HIYZ9ELIwHEfMgFsTd1rK10E6ArnHPIsEjzo1J6tsOxQhfxQF8ndBSVeuQUzwycm1fe1eb9t1xdqc+1p/TrGxO4sKNd9svZxibV1j67bZshhTqogZYWtxAnIH3RYxtg2mGk9oxXK2RqciZncxo+nrYW7jdt3T9t3xxMLvQ7DyFTWc17sgBcZumALKzu+KxWzVqF9PEAXmHsiKtwByAX4QMaSXobCBEGM5CbnsDrHxbjC1P6L1v0SKyMG2ht7G4rYQY/8hzVzKqAbjGUqNbJfM+SMQ3/G4Pf+a9fy+E1LgpMXtq6rdV+tnn03jezBSsj2LlFaL23yqaW3LKvveGyl6uiArbsgV8A5WMgEpbnfEspomvz2OpI5pA/cJPNFuiIeZgpQCCyO36jcpCM35iEd275zL4JzrgJij1dDG/zcUIP+ufb8M8Bfv/Te162XrROLC0AFp4n9EDNivkCA+FPmnj67WzaGB+/3k/uOcu8Xu9Rtr80Lv/a+cc+OBC7z3/0h+1xWVc9gUCYHPWR/eQS6lz9h1w5HV8hWklVsOuSJtN+ujlFEJ5qa6FXK53QW9x29RLNtO3vvXatUv7713zh2JMmdeYdniVkQb60U+ZlGt1yUtWSNtkLX7e1sv+xFTtX+ErAErIjfGycBj3vuvrY3+Psmu6ZzbEAlAfwX+jYS/tdBGf6L3/o+uQqZZc6nbxHt/cZMGqbTNMF7LAf9ALqnLIwF3L0QL7vfeP2h04A3gDW/Zdq2Nm4G3vfcT7fNlyMX6aZTsYhBKRnOX9/7XyT3HoTE8FCW5+I9z7h4Ug3lpcz1jNUj6NBJlj/4jsk4+gSxpn3nv/zc7+1To33DgGO/9COfc5sQM08d67+81l90dUDKRfkiwuNUpe/AolHXzae/9hVXcqxOwAVGx8QVibruhfWAdVErp0vqyT87JcKXZr5cgZp/sifaalRBz36h37pzbB1mIpnnL9pjc78u5cayaChvTg5Hn1r+R981DNe1UFbB10AV5ipyLaPTdKKbv98657dGaWxDxMq8hA8ajaJ+5sxH3ehbFEB+FFE3HOOdWsPYv9C2YnXVuRhb65iK4mNJ7LaLr1M9RdsiXgane+/+rZR/nBTjnLkbxRdPtXeyCNJgrAeO9SiZchRi4j1DMw+dISLwQ+K33/tNKjGpyn8BUnYKYylFI67cWyth3YHJtG2RxWBsR0j8hgWK09esDpIV7GVlYnkLath2Q0LEByoZ1tvf+g6aOUUbDcM5ti5jQ4WiTeqSGfalKOGmgjVRJcQESXj4Fzvfef+GUintRFMuxs303DCkzvkEa2ie89/9O4tsOR5axbxBjvr0JOp289/+0e8220iKJULsqijH9J1pLryJr/r98Ie7I1ZNq3KtkzFAkMB5ubfdFlqFt0NhPdc51RDRmZbvv6/abzVAtzbVb+NErwjk3GbjUaNoeKB7ue+Bh7/19NezXQKRk+xuK93kYCekjUcHwMFdDjNkRGIONPCX+5quI/0rm6gLIOt4VxWi9g+b79yhr62fN+4SzH865jZBH0QiUBOe05LvXkXDyTBXthHU0FCk7tkL7Ww8kOF5WvLaZH2WugMW4DfDev1rrvjQGTvkCRiKlx5Pe++NN6dkNCWkdUYzlcMTLvui9P7kR7XdFMeCfIbfdtez8TGC69/7q5nyeVoXZaVbMx6wfSHtyAjKDP0dMc9wbMeyXIT/5Jse45aPs+AcFyQooXmNE4fuVsPgaqnBzaMx9qb/AenAP28TaPx9plicS41LWQczm7YgQf2vX3oRlWAtzrNbjPC8ec8qaRXEXzyMBZjRSNMxM5m9VsacornUyYv7/i4S7c2yOHoNcci4Iz46sBONRjNvySXsLIGVFG5vTh9v5TUmyW9ZorK5AdbMWQR4XU1ESgY0p425O/anGT0MKoWuScw658oespDuipF19bN1fYu1chWUwrdE4bIXqjx2XnFsYeULM9mLxyRwchhjKqTbfetv5G4mxZHVKeCAL6qcoW2qj4muRdeMo+391o8FP2dzvOivPMyceVM4++UCVvw97aR+jNeOQO/SS9t6+wWK+8jF3HjZHVrN5EdwxD0OeR8ujWL+HkFKkQzmaWcU9tkZK9UtRop9tSMqB5KPCuNW6A/loxMtqBYG+c/uBXC4+RDEMS1MolZBc18mYn3uR9c2h5A5BMGyQyCWb46Z2zwOIMZzPk9QwMsK3mf3fHbnSvQ8sYucWRZaSiWGeIIvfp8gnfq6ONclH8xzUI5zU85u0RltPZDHsjrI3bm206X/2eRJym5tAknAKWZtHFtpdDAmDG2P1R+38cyQJlGbTuKTPuDZSmgxMzq2DFG+7NdBOmmp8KjGV+1IoJur/hTagbE3Hw5JzC1PjWlS0cOKcWXlHRGHiZGQ9DjGz2wGvVdFOo5N+IOXFRcAphfN30Erj0YgJmP6F+JJGvXuqrN1X6+fMR7PMlQHGa3yAyujshazhd5Ako2pkm+2QcvJCJPxdjyWDyUflI7t3zmWwdMhtkHvUN0gz2Rtljzu4ln1rrSjGMTmlgD8ZWf1uRW5Mv6/w27JuDr6ehZe4C82H0r53QozzGtbWB0hLPdKuXwtZ+H6DEmP81s7PQH7yT9rnkM7+TO/9ODu3FLIgXO29nzZLA5TR6mBuRaORAPgyyohWNlW4uRYv7L3/g31eHSmmbgKGe7lrXoGsUh2Rdej/UEzfm8gSMx4pKr7ycvsaYN8PQ8qOc7z35xr9G+G937Zlnrw80jhDpzTyZ6A6eZO999cl1zUYr2XjtQJykfsdyvb4pff+MefcpoimPOMtttY5dxjKXNoBZTn8E4pV+3WzPmQT4ErL37yO6n42WP6mhfpyMbIcfYDcTtd3zi2EwiA+9d7/piXi6pzKDpyKaOzrdv/nUbzulw3R/bkV5ka7lq+y/JD9pg1SFvyIBL9TvPfPO+fOQvVKR7VMbzNqBafyVacgBcHVKBndFqgG4z+b0G4XxCN9573/rjn62pqRhb65FHNroO/cBleavGUM0q5/i9yrVkTByp957w+q8PuOKD6nO0oK8EO1m78ld1ga+a3/h5iVsyNKyPKdU93CZZGLzRCkcf8GCYBnee9XT9rrgObLkYjwnu69f6uRQ5IxD8EYuo2991PquWYFZN27xHt/XHJ+CrLwdUcWqT2S7/oj69jq9vdT7/2eyfeXAg9572c4545F2v9lUWzs6d77d2ZnQgxL7vEJ8Ecfk9rshlyK/ovqis2sZm0nsbpXoCy636EkKB2Qm+R/nHMreO8/dErMNZPyNR2P9t5/2SIPPItwLZA4p5H3ryRMjAOWbElhwmKWhqNkLushmv2s937cvByXVgmucu2+7X0VMe8Zcwecc8MQnX8MZW7eBym1XnJW17SmHZzHkIW+uRxza6Dv3IJE6Dsf1Qx6CLmjrIOsHy8755b3SsjQ4CbVCCtfQwXW06QZnbz3/3TOrYRif7ZCQt8M7/31Ze7RAxiLtPJvoPiMmmjlM1oHnHPtUezpQcBJ3vtrTQAYixKxbOeVhTIt7NwWueL9D2Uc/t7Ob4ISVF3rvX/ROdfLrlkS+NArmVVNrCZmPe+H6q294ZxbBDExfSspfgq/DwLf4shDYKCdXxGlu//Ae39+YZwqacjX9nNIoek5CbUWJpwSFnVCFtzf2PtulVa+psI5tz7ar4YigeBF7/2FWeBrHTBFyByXsXpeRhb6MjIqwDnXzXv/N3PnfBzVHwqM6f5I2G7QXXMW7utQIoFbvfe3mfZ6RRR7dx7wiAmiy6KYiq9QIeCrvPevmPvZtqio7XvAdb5MGu1aa+UzWh/Mje565Pq4N0o89QAqa9LTW4bS+taMWdAmo2RFx3rv/zQ7+l4tnHODUObbV4CDjEZ08d5/24g2hiKL+7ne+1fsXHAPHOW9/3vWkM86sjAx98ApzX97xI/+1c5lIbkVws1BGavnVWShLyOjDJxz3VBWvfEoLftU4G7v/f32/WKI8RvpK8TzNeHeA1BSiEHIbfdmO/8gEuBus8/3oPiR/igz4r9QLMklyB1sF+AT7/3M5uxfRkZDMMHoIRSs/1ek6V3HV6ipl1i4N0UB+psgK83vUBzbNeUUF7WCKWZ2QQLunmFNVvnbAUhZA3JDfAUlNDgUFSw+IGvIm44sTGRkzJlwzrX3FWLEM1oWWejLyCgDCyj/F8rIthaKrTsZxdVNQVaMHt77fZuDkSi24SoUWPfeH2Dfr4LiVUY6515ByS5WRS5iN3vvzyreIyNjdsIEl5AoaCXkmniR9/6r8H3q+uac6w08g9bYx8By9vsBwHve+x1r8Rz1wSlmdwHv/TcNXFdc32MRTfkQlX3YCa3xE8zKVyIYZw15RkZGRkZTkYW+jIwycM7tjjL0tQf29t4/7lTA+kwUW/QccLH3/pvmdBlyzm1O/QXWTzOmsBsqw9ANZfLbySkT55HA8Rbjl7XaGTWBCXzO3JC3AN5GcWnDUXmRKd6SsCRC35HA9977K5yyQa6AhKGzUczpn+ZW97wkNngHtKZfRAlZNkSZLl8H/mfWzorPmDXkGRkZGRmziiz0ZWRUgHPuKlTb6V1koZhh5xfw3v/D/m8OK19gCDdBlsWHgb4oGcttljBiHWB3FCs1Bfjce///LMnFLSjD3wjgBe/9+CzwZcwJcM4thzLefoFcNQdhdSFRrb1v7bo+KKnQG977zZPf3wq86b2fOJu73uwwq+DtqPzKeajW36ko9vZg7/2LNexeRkZGRkYrRxb6MjIKSCwPq6N6YusDR6DSCWd6799vofteijJuPuSc6w4cAuyKilP/EdVj7IlinA72SlvfBpWE2A+VjrgkfYaW6GdGRn1I4vN2RclHuiJL1tfA2d77/znn1vHev1D43cbIut4BWQNfQkqQo7yy4871c9qydJ4JLICesTswDtjVe/9SDbuWkZGRkdHKkYW+jIwEidWtL7AgSoTyvVNdxKNRserhzS34ueoLrF8O/Np7f565zZ0BPOa9P6H4DM3Zv4yMxsI59zIqbfChWarHAN9474+u5zdtgT2ACSgZ0WTv/UWzpcMtCOfcEighy9soE/Bo4J8hSVNGRkZGRkZLo02tO5CRMacgEfhWBx4ETgJed86N9d5/470/EVi/hSx9fwfuRJkL93TOjXHObYbi9l61/nVEMYb/dM4djwpDnwEs65xbOTSUBb6MWsNKN/weWBzArHrHAgPMlbMsvPc/eNWWXBGYBOzlnJvqVAdwbkZX4N/Avmg9DwXOds4dCj8VFc/IyMjIyGgxZEtfRkYBzrkpwLve+yvN5ex0FHdzqvf+4Wa8TzUF1h8F/oFigX5AzPDlKBX+YZbc4l2Uxv2j5upbRkZT4ZzbG9gI1Zx8HmXjnOK9X7URbQwENvbeT2mZXs5+mFV/bWAwKt59ao27lJGRkZExDyALfRkZlFj51gIORFa3mYlQdjRKzT6ume/XUIH1gcCnwIUok+G93vtfJ+1cgzIejs1unRlzEpxzHYC9kKJiY+Bz4DLv/aM17dgcAudcu1B7MK/djIyMjIyWRhb6MjISOOcmA0OA91GWwV+FTJ3JNc1ZoqG+AusLIRe3z1H2w5Xs72soNuhrYGfgFu/9PzLjmDEnwsqLdEFlF76qdX8yMjIyMjLmRWShLyPDYMkmtkWxN6sBbVGh6IeBj5pboGqowDoS+DZA8T9tUMr7pRAD/RnwHvCI9/7frSGzYUZGRkZGRkZGRsugXa07kJExB+E3yMLXFxVfXxAYCfTz3h/RAvf7NXCKuZT+xnv/lnPu70jgnOy9/8459wxwEErx3gd4E/gRWf3mC7UDs8CXkZGRkZGRkZFRCTljWMY8Deecs79dvfe/995PA+5DgtUg4BngKrumyevFUtIHq2JnS77yOdDDOXcUStLyjff+W+vbRcAT3vthKK6vJ7C9/ebG5upXRkZGRkZGRkZG60VmFjPmaVgR9v7A2865E+zcu97781DM3G+99+/Z+Sa5d1rM3Q/OuR7AeUiAA/gTcCTQD7jfez/ezrdDmTs72f1f994fD/wB+Np7/2lz9CsjIyMjIyMjI6N1Iwt9GfM8vPdfoPpZazrnnnPO7eic6wSsADwA0SLYxPsE4ewc4D7v/TtWYP0VYHfv/eHe+0vsfm289/9F1rzBzrnRzrmVzVK4OPBQc/UrIyMjIyMjIyOjdSMncsnIMDjn2gE/B85E8X1Pee/PaI6smM65Luay2RG4FHgL6AwsCcwERgOne+/fLfzOAcOBDYH1gP8Az3rvx+VsnRkZGRkZGRkZGdUgC30ZGWXgnOvjvf+9/d+kzJjOua6o2PosF1h3znVGbp6dUdIXnzN2ZmRkZGRkZGRkVIMs9GVktDCcczsA3wLvALuQC6xnZGRkZGRkZGTMRuSSDRkZLQjnXB9gXZR8ZS1UamFR51xaYP0l4JaadTIjIyMjIyMjI6NVI1v6MjJaEOaWuQG5wHpGRkZGRkZGRkaNkLN3ZmS0EJxzbb3336FafwOBNZG173fAB8CywOre+39DLrCekZGRkZGRkZHRMshCX0ZGC8F7/4P9mwusZ2RkZGRkZGRk1Aw5pi8jowXhnGtPocA68Lpz7k5ygfWMjIyMjIyMjIzZgGxdyMhoQeQC6xkZGRkZGRkZGbVGTuSSkdHCyAXWMzIyMjIyMjIyaoks9GVkzCbkAusZGRkZGRkZGRm1QBb6MjIyMjIyMjIyMjIyWjFyTF9GRkZGRkZGRkZGRkYrRhb6MjIyMjIyMjIyMjIyWjGy0JeRkZGRkZGRkZGRkdGKkYW+jIyMjIyMjIyMjIyMVows9GVkZGRkzNNwzv3gnHsrOfrPQhvbOedWbP7eZWRkZGRkNB3tat2BjIyMjIyMGuN77/0qTWxjO+B+4INqf+Cca+e9/18T75uRkZGRkdEgsqUvIyMjIyOjAOfcYOfc0865151zDzvnFrXz+zvnXnXOve2cm+6c6+ScWwfYBjjfLIVLO+eecs6tbr/p6Zz7wv4f7Zy7wzk3A3jEOdfZOXeNtfmmc27bWj1zRkZGRkbrRRb6MjIyMjLmdcyfuHbe7ZxrD1wCjPTeDwauAc62a+/y3q/hvR8EfAjs671/AbgPONZ7v4r3/lcN3G8IMMp7vxFwMvCE934NYEMkOHZugWfMyMjIyJiHkd07MzIyMjLmdZS4dzrnVgJWAh51zgG0Bb6yr1dyzp0FdAe6AA/Pwv0e9d7/2f7fFNjGOXeMfZ4PWAIJlBkZGRkZGc2CLPRlZGRkZGSUwgHve++HlPnuOmA77/3bzrnRwAYV2vgf0ZtmvsJ33xXutaP3/uNZ7m1GRkZGRkYDyO6dGRkZGRkZpfgY6OWcGwLgnGvvnBto3y0AfGUuoLsnv/mHfRfwBTDY/h9Zz70eBg51ZlJ0zq3a9O5nZGRkZGSUIgt9GRkZGRkZCbz3/0GC2kTn3NvAW8A69vWpwMvAo8BHyc9uBY61ZCxLAxcABznnXgB61nO7M4H2wDvOuffsc0ZGRkZGRrPCee9r3YeMjIyMjIyMjIyMjIyMFkK29GVkZGRkZGRkZGRkZLRiZKEvIyMjIyMjIyMjIyOjFSMLfRkZGRkZGRkZGRkZGa0YWejLyMjIyMjIyMjIyMhoxchCX0ZGRkZGRkZGRkZGRitGFvoyMjIyMjIyMjIyMjJaMbLQl5GRkZGRkZGRkZGR0Yrx/wEEeczZPkPj8wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 提取特征名与系数\n",
    "vect = grid.best_estimator_.named_steps['tfidfvectorizer']\n",
    "feature_names = np.array(vect.get_feature_names())\n",
    "coef = grid.best_estimator_.named_steps['logisticregression'].coef_\n",
    "mglearn.tools.visualize_coefficients(coef,feature_names,n_top_features=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
